Subversion Repositories Games.Chess Giants

Rev

Rev 56 | Rev 60 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. // main.cpp
  2.  
  3. #define DEFINE_GLOBALS
  4. #include "common.h"
  5.  
  6.  
  7. // handy macros
  8. #define GUIBUTTON_ENABLE(button) { if ((button).state == 0) (button).state = 1; }
  9. #define GUIBUTTON_DISABLE(button) { if ((button).state > 0) (button).state = 0; }
  10.  
  11.  
  12. // prototypes of locally used functions
  13. static void MainLoop_FindCurrentViewer (void);
  14. static void MainLoop_EvaluateGameState (void);
  15.  
  16.  
  17. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, char *lpCmdLine, int nCmdShow)
  18. {
  19.    // the entry point for any Windows program
  20.  
  21.    WNDCLASSEX wc;
  22.    MENUINFO menu_info;
  23.    MSG msg;
  24.    HBITMAP hSplashBmp;
  25.    BITMAP splash_bmp;
  26.    HDC hdc;
  27.    RECT rect;
  28.    PAINTSTRUCT ps;
  29.    HBITMAP hbmTmp;
  30.    HDC hdcMem;
  31.    float previous_time;
  32.    int frame_count;
  33.    int array_index;
  34.    char *endptr;
  35.    wchar_t app_pathname[MAX_PATH];
  36.    wchar_t font_pathname[MAX_PATH];
  37.    wchar_t temp_string[100];
  38.    struct _stat fileinfo;
  39.  
  40.    // save application instance
  41.    hAppInstance = hInstance;
  42.  
  43.    // find module and path names, and *IMPORTANT*, set the current working directory there
  44.    GetModuleFileName (NULL, app_pathname, WCHAR_SIZEOF (app_pathname));
  45.    GetDirectoryPath (app_pathname, app_path);
  46.    SetCurrentDirectoryW (app_path);
  47.  
  48.    // initialize stuff
  49.    is_registered = false;
  50.    terminate_everything = false;
  51.    hMainWnd = NULL;
  52.    hChatterChannelsWnd = NULL;
  53.    hGamesWnd = NULL;
  54.    hMOTDWnd = NULL;
  55.    hOpponentsWnd = NULL;
  56.    hSoughtWnd = NULL;
  57. #ifdef NDEBUG
  58.    want_framerate = false; // release mode, don't display framerate
  59. #else
  60.    want_framerate = true; // display framerate in debug mode
  61. #endif // NDEBUG
  62.    is_dialogbox_about_validated = false;
  63.    is_dialogbox_challenge_validated = false;
  64.    is_dialogbox_changeappearance_validated = false;
  65.    is_dialogbox_comment_validated = false;
  66.    is_dialogbox_endgame_validated = false;
  67.    is_dialogbox_gotomove_validated = false;
  68.    is_dialogbox_load_validated = false;
  69.    is_dialogbox_message_validated = false;
  70.    is_dialogbox_newgame_validated = false;
  71.    is_dialogbox_options_validated = false;
  72.    is_dialogbox_pawnpromotion_validated = false;
  73.    is_dialogbox_playercard_validated = false;
  74.    is_dialogbox_playerinfoname_validated = false;
  75.    is_dialogbox_quit_validated = false;
  76.    is_dialogbox_resign_validated = false;
  77.    is_dialogbox_save_validated = false;
  78.    is_dialogbox_saveposition_validated = false;
  79.    is_dialogbox_sendchallenge_validated = false;
  80.    is_dialogbox_sendseek_validated = false;
  81.    is_dialogbox_takeback_validated = false;
  82.    is_window_chat_validated = false;
  83.    is_window_chatterchannels_validated = false;
  84.    is_window_games_validated = false;
  85.    is_window_motd_validated = false;
  86.    is_window_opponents_validated = false;
  87.    is_window_sought_validated = false;
  88.    save_pathname[0] = 0;
  89.    srand ((unsigned int) time (NULL)); // initialize PRNG
  90.    animation_endtime = 0.0f;
  91.    command_ignoretime = 0.0f;
  92.    sound_playtime = 0.0f;
  93.    highlight_endtime = 0.0f;
  94.    previous_time = 0.0f;
  95.    frame_count = 0;
  96.  
  97.    // load the texts and ensure we have at least one display language
  98.    LocalizedTexts_Init ();
  99.    if (language_count < 1)
  100.    {
  101.       MessageBox (NULL, L"Chess Giants was unable to load its data files.\nThe game cannot start.\n\nPlease reinstall this program to fix the problem.", L"Chess Giants", MB_ICONERROR | MB_OK);
  102.       return (-1); // bomb out on error
  103.    }
  104.  
  105.    // read configuration data
  106.    Config_Load ();
  107.  
  108.    // see if the program is registered
  109.    is_registered = IsRegistrationCorrect (options.registration.user_email, options.registration.activation_code);
  110.  
  111.    // register the window class, create the window and show it
  112.    memset (&wc, 0, sizeof (wc));
  113.    wc.cbSize = sizeof (wc);
  114.    wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS; // double-clicks support
  115.    wc.lpfnWndProc = WindowProc_Main;
  116.    wc.hInstance = hAppInstance;
  117.    wc.hIcon = LoadIcon (hAppInstance, (wchar_t *) ICON_MAIN);
  118.    wc.hCursor = LoadCursor (NULL, IDC_ARROW);
  119.    wc.lpszClassName = PROGRAM_NAME L" WndClass";
  120.    RegisterClassEx (&wc);
  121.    swprintf_s (temp_string, WCHAR_SIZEOF (temp_string), PROGRAM_NAME L"%s", (is_registered ? L"" : LOCALIZE (L"EvaluationMode"))); // build window title
  122.    if (options.want_fullscreen)
  123.       hMainWnd = CreateWindowEx (0, wc.lpszClassName, temp_string, WS_POPUPWINDOW, // temp_string holds window title
  124.                                  0, 0, GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN), NULL, NULL, hAppInstance, NULL);
  125.    else
  126.    {
  127.       // in windowed mode, ensure window width and height aren't greater than screen size nor lower than a safe minimum
  128.       if (options.window_width > GetSystemMetrics (SM_CXMAXTRACK))
  129.          options.window_width = GetSystemMetrics (SM_CXMAXTRACK); // check this first in case screen size is reported incorrect
  130.       if (options.window_height > GetSystemMetrics (SM_CYMAXTRACK))
  131.          options.window_height = GetSystemMetrics (SM_CYMAXTRACK);
  132.       if (options.window_width < 640)
  133.          options.window_width = 640; // check this secondly in case screen size is reported incorrect
  134.       if (options.window_height < 480)
  135.          options.window_height = 480;
  136.  
  137.       hMainWnd = CreateWindowEx (0, wc.lpszClassName, temp_string, WS_OVERLAPPEDWINDOW, // temp_string holds window title
  138.                                  GetSystemMetrics (SM_CXSCREEN) / 2 - options.window_width / 2,
  139.                                  GetSystemMetrics (SM_CYSCREEN) / 2 - options.window_height / 2,
  140.                                  options.window_width, options.window_height, NULL, NULL, hAppInstance, NULL);
  141.    }
  142.    ShowWindow (hMainWnd, nCmdShow);
  143.  
  144.    // create the main menu line, and its accelerators
  145.    hMainMenu = NULL;
  146.    hMainAccelerators = NULL;
  147.    CreateOrUpdateApplicationMenu ();
  148.  
  149.    // display the splash screen
  150.    memset ((void *) &splash_bmp, 0, sizeof (splash_bmp));
  151.    hSplashBmp = W32LoadImage (L"%s/data/splash.bmp", app_path); // load the splash bitmap
  152.    GetObject (hSplashBmp, sizeof (splash_bmp), (void *) &splash_bmp); // get a structure containing its size (among others)
  153.    hdcMem = CreateCompatibleDC (NULL); // create a device context compatible with the screen
  154.    hbmTmp = SelectBitmap (hdcMem, hSplashBmp); // select our bitmap to use in it
  155.    hdc = BeginPaint (hMainWnd, &ps); // begin painting on the main window
  156.    GetClientRect (hMainWnd, &rect);
  157.    StretchBlt (hdc, 0, 0, rect.right, rect.bottom, hdcMem, 0, 0, splash_bmp.bmWidth, splash_bmp.bmHeight, SRCCOPY); // bit blit the bitmap into it
  158.    EndPaint (hMainWnd, &ps); // end painting on the main window
  159.    SelectObject (hdcMem, hbmTmp); // restore the previous selection
  160.    DeleteDC (hdcMem); // and delete the handles to the device context
  161.    DeleteObject (hSplashBmp); // and to the bitmap that we used
  162.  
  163.    // make the menu modeless
  164.    memset (&menu_info, 0, sizeof (menu_info)); // prepare menu info structure
  165.    menu_info.cbSize = sizeof (MENUINFO);
  166.    menu_info.fMask = MIM_STYLE;
  167.    GetMenuInfo (GetMenu (hMainWnd), &menu_info); // get current style
  168.    menu_info.dwStyle |= MNS_MODELESS; // add the "modeless" flag
  169.    SetMenuInfo (GetMenu (hMainWnd), &menu_info); // and send it back
  170.  
  171.    // load status icons, bitmaps and texts
  172.    handlestatus[HANDLESTATUS_AVAILABLE].icon = W32LoadIcon (L"%s/data/icons/available.ico", app_path);
  173.    handlestatus[HANDLESTATUS_AVAILABLE].bitmap = W32LoadImage (L"%s/data/status/available.bmp", app_path);
  174.    handlestatus[HANDLESTATUS_AVAILABLE].text = LOCALIZE (L"Opponents_StatusAvailable");
  175.    handlestatus[HANDLESTATUS_INGAME].icon = W32LoadIcon (L"%s/data/icons/ingame.ico", app_path);
  176.    handlestatus[HANDLESTATUS_INGAME].bitmap = W32LoadImage (L"%s/data/status/ingame.bmp", app_path);
  177.    handlestatus[HANDLESTATUS_INGAME].text = LOCALIZE (L"Opponents_StatusInGame");
  178.    handlestatus[HANDLESTATUS_INSIMULATION].icon = W32LoadIcon (L"%s/data/icons/insimulation.ico", app_path);
  179.    handlestatus[HANDLESTATUS_INSIMULATION].bitmap = W32LoadImage (L"%s/data/status/insimulation.bmp", app_path);
  180.    handlestatus[HANDLESTATUS_INSIMULATION].text = LOCALIZE (L"Opponents_StatusInSimulation");
  181.    handlestatus[HANDLESTATUS_INTOURNAMENT].icon = W32LoadIcon (L"%s/data/icons/intournament.ico", app_path);
  182.    handlestatus[HANDLESTATUS_INTOURNAMENT].bitmap = W32LoadImage (L"%s/data/status/intournament.bmp", app_path);
  183.    handlestatus[HANDLESTATUS_INTOURNAMENT].text = LOCALIZE (L"Opponents_StatusInTournament");
  184.    handlestatus[HANDLESTATUS_EXAMININGAGAME].icon = W32LoadIcon (L"%s/data/icons/examiningagame.ico", app_path);
  185.    handlestatus[HANDLESTATUS_EXAMININGAGAME].bitmap = W32LoadImage (L"%s/data/status/examiningagame.bmp", app_path);
  186.    handlestatus[HANDLESTATUS_EXAMININGAGAME].text = LOCALIZE (L"Opponents_StatusExaminingAGame");
  187.    handlestatus[HANDLESTATUS_NOTOPENFORAMATCH].icon = W32LoadIcon (L"%s/data/icons/notopenforamatch.ico", app_path);
  188.    handlestatus[HANDLESTATUS_NOTOPENFORAMATCH].bitmap = W32LoadImage (L"%s/data/status/notopenforamatch.bmp", app_path);
  189.    handlestatus[HANDLESTATUS_NOTOPENFORAMATCH].text = LOCALIZE (L"Opponents_StatusNotOpenForAMatch");
  190.    handlestatus[HANDLESTATUS_INACTIVEORBUSY].icon = W32LoadIcon (L"%s/data/icons/inactiveorbusy.ico", app_path);
  191.    handlestatus[HANDLESTATUS_INACTIVEORBUSY].bitmap = W32LoadImage (L"%s/data/status/inactiveorbusy.bmp", app_path);
  192.    handlestatus[HANDLESTATUS_INACTIVEORBUSY].text = LOCALIZE (L"Opponents_StatusInactiveOrBusy");
  193.    handlestatus[HANDLESTATUS_OFFLINE].icon = W32LoadIcon (L"%s/data/icons/offline.ico", app_path);
  194.    handlestatus[HANDLESTATUS_OFFLINE].bitmap = W32LoadImage (L"%s/data/status/offline.bmp", app_path);
  195.    handlestatus[HANDLESTATUS_OFFLINE].text = LOCALIZE (L"Opponents_StatusOffline");
  196.  
  197.    // load the system fonts
  198.    hFontChat = CreateFont (17, 0, 0, 0, FW_DONTCARE, false, false, false, ANSI_CHARSET, OUT_DEFAULT_PRECIS,
  199.                            CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_SWISS, L"Comic Sans MS");
  200.  
  201.    // before any rendering is done, it's a good idea to know what time it is
  202.    current_time = ProcessTime ();
  203.  
  204.    // initialize renderer
  205.    if (!Render_Init ())
  206.       return (-1); // bomb out on error
  207.  
  208.    // load sprites
  209.    larrow_spriteindex = Render_LoadSprite (L"%s/data/sprites/arrow-left.*", app_path);
  210.    rarrow_spriteindex = Render_LoadSprite (L"%s/data/sprites/arrow-right.*", app_path);
  211.    chatbutton_spriteindex = Render_LoadSprite (L"%s/data/sprites/chat.*", app_path);
  212.    gamesbutton_spriteindex = Render_LoadSprite (L"%s/data/sprites/games.*", app_path);
  213.    peoplebutton_spriteindex = Render_LoadSprite (L"%s/data/sprites/people.*", app_path);
  214.    sepia_spriteindex = Render_LoadSprite (L"%s/data/sprites/sepia.*", app_path);
  215.    for (array_index = 0; array_index < 12; array_index++)
  216.       spinner_spriteindex[array_index] = Render_LoadSprite (L"%s/data/sprites/spinner-%d.png", app_path, array_index * 30); // spinning wheel
  217.  
  218.    // add our custom fonts to the list of available fonts for the duration of the process
  219.    swprintf_s (font_pathname, WCHAR_SIZEOF (font_pathname), L"%s/data/fonts/papyrus.ttf", app_path);
  220.    AddFontResourceEx (font_pathname, FR_PRIVATE, 0);
  221.    // load rendered fonts
  222.    arrow_fontindex = Render_LoadFont (L"Papyrus", 24, false, false);
  223.    chat_fontindex = Render_LoadFont (L"Papyrus", 32, false, false);
  224.    players_fontindex = Render_LoadFont (L"Papyrus", 40, false, true);
  225.    centermsg_fontindex = Render_LoadFont (L"Papyrus", 54, false, true);
  226.  
  227.    // load themes, initialize a new human vs. human game and setup the scene
  228.    if (!Themes_Init ())
  229.       return (-1); // bomb out on error
  230.    Board_Init (&the_board, PLAYER_HUMAN, PLAYER_HUMAN, FENSTARTUP_STANDARDCHESS);
  231.    Scene_Init (&the_scene, &the_board);
  232.  
  233.    // has a filename been specifed on the command-line AND that file exists ?
  234.    if ((lpCmdLine != NULL) && (lpCmdLine[0] != 0))
  235.    {
  236.       while (*lpCmdLine == '"')
  237.          lpCmdLine++; // skip leading quotes
  238.       if ((endptr = strchr (lpCmdLine, '"')) != NULL)
  239.          *endptr = 0; // break the string at the first ending quote
  240.  
  241.       // is it a file that exists ?
  242.       if (_stat (lpCmdLine, &fileinfo) == 0)
  243.       {
  244.          ConvertToWideChar (load_pathname, WCHAR_SIZEOF (load_pathname), lpCmdLine); // save pathname string
  245.          is_dialogbox_load_validated = true; // and act as if the user just validated a load dialog box
  246.       }
  247. #ifndef NDEBUG
  248.       // else is it a registration info ? if so, parse it
  249.       else if ((strncmp (lpCmdLine, "/r=", 3) == 0) && ((endptr = strchr (&lpCmdLine[3], ',')) != NULL))
  250.       {
  251.          *endptr = 0; // break the string at the separator between user email and activation code
  252.          ConvertToWideChar (temp_string, WCHAR_SIZEOF (temp_string), &lpCmdLine[3]); // read user email
  253.          is_registered = IsRegistrationCorrect (temp_string, atoi (endptr + 1)); // and see whether we're registered or not
  254.          DialogBox_NewGame (); // still open the "new game" dialog box
  255.       }
  256. #endif // !NDEBUG
  257.       else
  258.          DialogBox_NewGame (); // if specified filename doesn't exist, fallback to the "new game" dialog box
  259.    }
  260.    else
  261.       DialogBox_NewGame (); // when no filename is specified, display the new game dialog box
  262.  
  263.    // enter the main loop
  264.    while (!terminate_everything)
  265.    {
  266.       // see what time it is
  267.       current_time = ProcessTime ();
  268.  
  269.       // are we in demo mode and is it time to quit ?
  270.       if (!is_registered && (current_time > DEMO_TIMEOUT))
  271.          DestroyWindow (hMainWnd); // if so, send a quit message in order to break the loop
  272.  
  273.       // grab the current window size
  274.       GetWindowRect (hMainWnd, &rect);
  275.       options.window_width = rect.right - rect.left;
  276.       options.window_height = rect.bottom - rect.top;
  277.  
  278.       // are we in the middle of an animation or just after it ?
  279.       if (current_time < animation_endtime + 0.5f)
  280.          the_scene.update = true; // always update during animations
  281.       else
  282.          the_scene.update |= Board_Think (&the_board); // make the board (i.e, both players) think
  283.  
  284.       MainLoop_FindCurrentViewer ();  // determine current viewer
  285.  
  286.       // see if we have a message waiting for any window in the current thread and dispatch it
  287.       while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
  288.       {
  289.          // check for accelerator keystrokes from the main window
  290.          if ((msg.hwnd != hMainWnd) || !TranslateAccelerator (hMainWnd, hMainAccelerators, &msg))
  291.          {
  292.             TranslateMessage (&msg); // translate and dispatch all other messages
  293.             DispatchMessage (&msg);
  294.          }
  295.       }
  296.  
  297.       // handle dialog box and window return codes
  298.       if (is_dialogbox_about_validated) DialogBox_About_Validated ();
  299.       if (is_dialogbox_challenge_validated) DialogBox_Challenge_Validated ();
  300.       if (is_dialogbox_changeappearance_validated) DialogBox_ChangeAppearance_Validated ();
  301.       if (is_dialogbox_comment_validated) DialogBox_Comment_Validated ();
  302.       if (is_dialogbox_endgame_validated) DialogBox_EndGame_Validated ();
  303.       if (is_dialogbox_gotomove_validated) DialogBox_GoToMove_Validated ();
  304.       if (is_dialogbox_load_validated) DialogBox_Load_Validated ();
  305.       if (is_dialogbox_message_validated) DialogBox_Message_Validated ();
  306.       if (is_dialogbox_newgame_validated) DialogBox_NewGame_Validated ();
  307.       if (is_dialogbox_options_validated) DialogBox_Options_Validated ();
  308.       if (is_dialogbox_pawnpromotion_validated) DialogBox_PawnPromotion_Validated ();
  309.       if (is_dialogbox_playercard_validated) DialogBox_PlayerCard_Validated ();
  310.       if (is_dialogbox_playerinfoname_validated) DialogBox_PlayerInfoName_Validated ();
  311.       if (is_dialogbox_quit_validated) DialogBox_Quit_Validated ();
  312.       if (is_dialogbox_resign_validated) DialogBox_Resign_Validated ();
  313.       if (is_dialogbox_save_validated) DialogBox_Save_Validated ();
  314.       if (is_dialogbox_saveposition_validated) DialogBox_SavePosition_Validated ();
  315.       if (is_dialogbox_sendchallenge_validated) DialogBox_SendChallenge_Validated ();
  316.       if (is_dialogbox_sendseek_validated) DialogBox_SendSeek_Validated ();
  317.       if (is_dialogbox_takeback_validated) DialogBox_Takeback_Validated ();
  318.       if (is_window_chat_validated) Window_Chat_Validated ();
  319.       if (is_window_chatterchannels_validated) Window_ChatterChannels_Validated ();
  320.       if (is_window_games_validated) Window_Games_Validated ();
  321.       if (is_window_motd_validated) Window_MOTD_Validated ();
  322.       if (is_window_opponents_validated) Window_Opponents_Validated ();
  323.       if (is_window_sought_validated) Window_Sought_Validated ();
  324.  
  325.       MainLoop_EvaluateGameState (); // evaluate game state
  326.  
  327.       // is the table rotating ?
  328.       if (Player_RotateTable (&the_board.players[current_viewer], current_time - previous_time))
  329.          the_scene.update = true; // if so, update the scene
  330.  
  331.       // are we highlighting something ?
  332.       if (highlight_endtime > current_time)
  333.          the_scene.update = true; // if so, update the scene
  334.  
  335.       // else if we WERE just highlighting something, clear the hovered positions
  336.       else if (highlight_endtime + 0.1f > current_time)
  337.       {
  338.          the_board.hovered_position[0] = -1;
  339.          the_board.hovered_position[1] = -1;
  340.          the_scene.update = true; // and update the scene
  341.       }
  342.  
  343.       // if we want the game clock, update scene every second
  344.       if (options.want_clock && ((int) current_time != (int) previous_time))
  345.          the_scene.update = true;
  346.  
  347.       // if there's something in the central text buffer, update scene too
  348.       if (the_scene.gui.central_text.is_displayed)
  349.          the_scene.update = true;
  350.  
  351.       // if we have a spinning wheel, update scene too
  352.       if (the_scene.gui.want_spinwheel)
  353.          the_scene.update = true;
  354.  
  355.       // do we NOT need to update the scene ?
  356.       if (!the_scene.update)
  357.       {
  358.          // cycle through all themes and see if one of them needs to be loaded
  359.          for (array_index = 0; array_index < theme_count; array_index++)
  360.             if (!themes[array_index].is_loaded)
  361.             {
  362.                Theme_Load (&themes[array_index], false); // load a bit more of this theme
  363.                break; // and stop looping (see you next pass)
  364.             }
  365.       }
  366.  
  367.       // do we need to update the scene ?
  368.       if (the_scene.update || want_framerate)
  369.       {
  370.          Scene_Update (&the_scene, &the_board); // evaluate which parts need to be placed
  371.          Render_RenderFrame (&the_scene); // render a game frame
  372.  
  373.          the_scene.update = false; // scene no longer needs to be updated now
  374.       }
  375.  
  376.       Audio_Think (); // ensure audio is playing
  377.  
  378.       previous_time = current_time; // save previous time
  379.       if (frame_count == 100)
  380.       {
  381.          frame_count = 0; // reset frame count every 100 frames
  382.          Sleep (1); // once every 100 frames, wait a millisecond
  383.       }
  384.       else
  385.          Sleep (0); // else just allow context switching
  386.       frame_count++; // increase the frame count
  387.    }
  388.  
  389.    /////////////////////////////////////////////////////////////////////////
  390.    // at this point, we exited the main loop and we are returning to Windows
  391.  
  392.    // release scene, game, themes and shutdown Direct3D
  393.    Scene_Shutdown (&the_scene);
  394.    Board_Shutdown (&the_board);
  395.    Themes_Shutdown ();
  396.    Render_Shutdown ();
  397.  
  398.    // delete the font resources
  399.    DeleteObject (hFontChat);
  400.  
  401.    // delete the bitmap and icon ressources
  402.    for (array_index = 1; array_index < sizeof (handlestatus) / sizeof (handlestatus[0]); array_index++)
  403.    {
  404.       DeleteObject (handlestatus[array_index].bitmap);
  405.       DestroyIcon (handlestatus[array_index].icon);
  406.    }
  407.  
  408.    // unregister window class
  409.    UnregisterClass (wc.lpszClassName, hAppInstance);
  410.  
  411.    // destroy the accelerators table
  412.    if (hMainAccelerators)
  413.       DestroyAcceleratorTable (hMainAccelerators);
  414.    hMainAccelerators = NULL;
  415.  
  416.    // destroy the application menu object
  417.    if (IsMenu (hMainMenu))
  418.       DestroyMenu (hMainMenu);
  419.    hMainMenu = NULL;
  420.  
  421.    // are we not registered yet ?
  422.    if (!is_registered)
  423.       DialogBox_Registration ();
  424.  
  425.    // save configuration data
  426.    Config_Save ();
  427.  
  428.    // unload localized texts
  429.    LocalizedTexts_Shutdown ();
  430.  
  431.    return (0); // and return to Windows.
  432. }
  433.  
  434.  
  435. static void MainLoop_FindCurrentViewer (void)
  436. {
  437.    // helper function that tells who is the current viewer
  438.  
  439.    if ((the_board.players[COLOR_WHITE].type == PLAYER_HUMAN) && (the_board.players[COLOR_BLACK].type == PLAYER_HUMAN))
  440.       current_viewer = Board_ColorToMove (&the_board); // if both players are human, track them both
  441.    else if (the_board.players[COLOR_WHITE].type == PLAYER_HUMAN)
  442.       current_viewer = COLOR_WHITE; // else if only the white is human, track the white
  443.    else if (the_board.players[COLOR_BLACK].type == PLAYER_HUMAN)
  444.       current_viewer = COLOR_BLACK; // else if it's the black, track the black
  445.    else
  446.       current_viewer = COLOR_WHITE; // else no human in game, track just the white
  447.  
  448.    return; // finished, current viewer is known
  449. }
  450.  
  451.  
  452. static void MainLoop_EvaluateGameState (void)
  453. {
  454.    // function to evaluate the game state in the main loop when a part has just moved
  455.  
  456.    static wchar_t window_title[256];
  457.  
  458.    player_t *current_player;
  459.    player_t *opposite_player;
  460.    player_t *network_player;
  461.    boardmove_t *last_move;
  462.    int enabled_value;
  463.    int move_index;
  464.  
  465.    if (!the_board.reevaluate)
  466.       return; // if the board doesn't need to be reevaluated, don't do anything
  467.  
  468.    // get current and opposite players
  469.    current_player = Player_GetCurrent ();
  470.    opposite_player = Player_GetOpposite ();
  471.  
  472.    // see if we're online
  473.    network_player = Player_FindByType (PLAYER_INTERNET);
  474.  
  475.    // has the game started ?
  476.    if (the_board.move_count > 1)
  477.    {
  478.       // game has started, enable the "save" and "save as" menu options
  479.       EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_SAVE, MF_ENABLED);
  480.       EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_SAVEAS, MF_ENABLED);
  481.       EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_SAVEPOSITIONAS, MF_ENABLED);
  482.  
  483.       // enable the "go to move" menu option
  484.       EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_GOTOMOVE, MF_ENABLED);
  485.  
  486.       // are we watching the last move ?
  487.       if (the_board.viewed_move == the_board.move_count - 1)
  488.       {
  489.          // get a quick acccess to the last move
  490.          last_move = &the_board.moves[the_board.move_count - 1];
  491.  
  492.          // if the current player is a human AND its opponent is a computer, allow him to ask us for a hint
  493.          if ((current_player->type == PLAYER_HUMAN) && (opposite_player->type == PLAYER_COMPUTER))
  494.             EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_SUGGESTMOVE, MF_ENABLED);
  495.          else
  496.             EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_SUGGESTMOVE, MF_GRAYED);
  497.  
  498.          // (if the current player is a human
  499.          //  AND (its opponent is another human AND there's at least one move played)
  500.          //       OR (its opponent is a computer AND there are at least two moves played)
  501.          //       OR (its opponent is a remote player AND we're in game AND there are at least two moves played))
  502.          // OR the current player is a remote player AND we're in game AND there are at least two moves played), allow him to cancel move
  503.          if (((current_player->type == PLAYER_HUMAN)
  504.               && ((opposite_player->type == PLAYER_HUMAN)
  505.                   || ((opposite_player->type == PLAYER_COMPUTER) && (the_board.move_count > 2))
  506.                   || ((opposite_player->type == PLAYER_INTERNET) && (opposite_player->is_in_game) && (the_board.move_count > 2))))
  507.              || ((current_player->type == PLAYER_INTERNET) && (current_player->is_in_game) && (the_board.move_count > 2)))
  508.             EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_CANCELLASTMOVE, MF_ENABLED);
  509.          else
  510.             EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_CANCELLASTMOVE, MF_GRAYED);
  511.  
  512.          // is the current player in check ? (to play the right sound)
  513.          // read as: was the last move an opponent's move AND did it put us to check ?
  514.          if (last_move->is_check)
  515.          {
  516.             // is it a checkmate ? (checkmate == check + stalemate)
  517.             if (last_move->is_stalemate)
  518.             {
  519.                // display the game over dialog box
  520.                the_board.game_state = (Board_ColorToMove (&the_board) == COLOR_WHITE ? STATE_BLACKWIN_CHECKMATE : STATE_WHITEWIN_CHECKMATE);
  521.                DialogBox_EndGame ();
  522.             }
  523.          }
  524.          else
  525.          {
  526.             // is it a stalemate ?
  527.             if (last_move->is_stalemate)
  528.             {
  529.                // display the game over dialog box
  530.                the_board.game_state = STATE_DRAW_STALEMATE;
  531.                DialogBox_EndGame ();
  532.             }
  533.          }
  534.  
  535.          // have there 50 moves been played each side (i.e, 100 plies) AND is the current player human ?
  536.          if ((the_board.move_count > 100) && (current_player->type == PLAYER_HUMAN))
  537.          {
  538.             // go backwards and see when is the latest move that took an opponent's piece OR the latest pawn move
  539.             for (move_index = the_board.move_count - 1; move_index >= 0; move_index--)
  540.                if (the_board.moves[move_index].has_captured || (the_board.moves[move_index].part == PART_PAWN))
  541.                   break; // stop as soon as we find one
  542.  
  543.             // can the fifty moves draw rule be claimed AND does the current player claims it ?
  544.             if (move_index + 1 + 100 < the_board.move_count)
  545.             {
  546.                // yes. Propose it to the side that's on move
  547. // TODO: non-modal MessageBox (copy dialog_newgame.cpp and use return values)
  548.             }
  549.          }
  550.  
  551.          if (the_scene.gui.larrow.state == 0)
  552.             the_scene.gui.larrow.state = 1; // enable "back" arrow if it isn't displayed yet
  553.          if (the_scene.gui.rarrow.state != 0)
  554.             the_scene.gui.rarrow.state = 0; // disable "forward" arrow if it's already displayed
  555.  
  556.          if (the_board.game_state == STATE_PLAYING)
  557.             Scene_SetText (&the_scene.gui.arrow_text, 3.3f, 5.0f, -1, ALIGN_CENTER, ALIGN_TOP, ALIGN_CENTER, arrow_fontindex,
  558.                            RGBACOLOR_SETALPHA (options.clock_color, 0x7f), 999999.0f, false, LOCALIZE (L"Current"));
  559.          else if ((the_board.game_state == STATE_BLACKWIN_CHECKMATE) || (the_board.game_state == STATE_WHITEWIN_CHECKMATE))
  560.             Scene_SetText (&the_scene.gui.arrow_text, 3.3f, 5.0f, -1, ALIGN_CENTER, ALIGN_TOP, ALIGN_CENTER, arrow_fontindex,
  561.                            RGBACOLOR_SETALPHA (options.clock_color, 0x7f), 999999.0f, false, LOCALIZE (L"EndGame_CheckMate"));
  562.          else if ((the_board.game_state == STATE_WHITEWIN_RESIGNORFORFEIT) || (the_board.game_state == STATE_BLACKWIN_RESIGNORFORFEIT))
  563.             Scene_SetText (&the_scene.gui.arrow_text, 3.3f, 5.0f, -1, ALIGN_CENTER, ALIGN_TOP, ALIGN_CENTER, arrow_fontindex,
  564.                            RGBACOLOR_SETALPHA (options.clock_color, 0x7f), 999999.0f, false, LOCALIZE (L"EndGame_Resign"));
  565.          else if (the_board.game_state == STATE_DRAW_STALEMATE)
  566.             Scene_SetText (&the_scene.gui.arrow_text, 3.3f, 5.0f, -1, ALIGN_CENTER, ALIGN_TOP, ALIGN_CENTER, arrow_fontindex,
  567.                            RGBACOLOR_SETALPHA (options.clock_color, 0x7f), 999999.0f, false, LOCALIZE (L"EndGame_StaleMate"));
  568.          else if (the_board.game_state == STATE_DRAW_AGREEMENT)
  569.             Scene_SetText (&the_scene.gui.arrow_text, 3.3f, 5.0f, -1, ALIGN_CENTER, ALIGN_TOP, ALIGN_CENTER, arrow_fontindex,
  570.                            RGBACOLOR_SETALPHA (options.clock_color, 0x7f), 999999.0f, false, LOCALIZE (L"EndGame_Agreement"));
  571.          else if (the_board.game_state == STATE_DRAW_OTHER)
  572.             Scene_SetText (&the_scene.gui.arrow_text, 3.3f, 5.0f, -1, ALIGN_CENTER, ALIGN_TOP, ALIGN_CENTER, arrow_fontindex,
  573.                            RGBACOLOR_SETALPHA (options.clock_color, 0x7f), 999999.0f, false, LOCALIZE (L"EndGame_DrawOther"));
  574.  
  575.          // enable the "comment on this move" menu option
  576.          EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_COMMENTMOVE, MF_ENABLED);
  577.       }
  578.  
  579.       // else are we watching another move, but not the beginning of the game ?
  580.       else if (the_board.viewed_move > 0)
  581.       {
  582.          if (the_scene.gui.larrow.state == 0)
  583.             the_scene.gui.larrow.state = 1; // enable "back" arrow if it isn't displayed yet
  584.          if (the_scene.gui.rarrow.state == 0)
  585.             the_scene.gui.rarrow.state = 1; // enable "forward" arrow if it isn't displayed yet
  586.          Scene_SetText (&the_scene.gui.arrow_text, 3.3f, 5.0f, -1, ALIGN_CENTER, ALIGN_TOP, ALIGN_CENTER, arrow_fontindex,
  587.                         RGBACOLOR_SETALPHA (options.clock_color, 0x7f), 999999.0f, false,
  588.                         L"%s %d\n%s", LOCALIZE (L"Move"), (the_board.viewed_move + 1) / 2, (the_board.viewed_move % 2 ? LOCALIZE (L"Games_White"): LOCALIZE (L"Games_Black")));
  589.  
  590.          // enable the "save position as" and "comment on this move" menu options
  591.          EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_SAVEPOSITIONAS, MF_ENABLED);
  592.          EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_COMMENTMOVE, MF_ENABLED);
  593.       }
  594.  
  595.       // else we must be watching the beginning of the game (no move yet)
  596.       else
  597.       {
  598.          if (the_scene.gui.larrow.state != 0)
  599.             the_scene.gui.larrow.state = 0; // disable "back" arrow if it's already displayed
  600.          if (the_scene.gui.rarrow.state == 0)
  601.             the_scene.gui.rarrow.state = 1; // enable "forward" arrow if it isn't displayed yet
  602.          Scene_SetText (&the_scene.gui.arrow_text, 3.3f, 5.0f, -1, ALIGN_CENTER, ALIGN_TOP, ALIGN_CENTER, arrow_fontindex,
  603.                         RGBACOLOR_SETALPHA (options.clock_color, 0x7f), 999999.0f, false, LOCALIZE (L"Beginning"));
  604.  
  605.          // disable the "save position as" and "comment on this move" menu options
  606.          EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_SAVEPOSITIONAS, MF_GRAYED);
  607.          EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_COMMENTMOVE, MF_GRAYED);
  608.       }
  609.    }
  610.    else
  611.    {
  612.       // game has not started, disable the "save", "save as" and "save position as" menu options
  613.       EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_SAVE, MF_GRAYED);
  614.       EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_SAVEAS, MF_GRAYED);
  615.       EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_SAVEPOSITIONAS, MF_GRAYED);
  616.  
  617.       // if the current player is a human AND its opponent is a computer, allow him to ask us for a hint
  618.       if ((current_player->type == PLAYER_HUMAN) && (opposite_player->type == PLAYER_COMPUTER))
  619.          EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_SUGGESTMOVE, MF_ENABLED);
  620.       else
  621.          EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_SUGGESTMOVE, MF_GRAYED);
  622.  
  623.       // disable the "cancel last move", "comment move" and "go to move" menu options
  624.       EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_CANCELLASTMOVE, MF_GRAYED);
  625.       EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_COMMENTMOVE, MF_GRAYED);
  626.       EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_GOTOMOVE, MF_GRAYED);
  627.  
  628.       // and disable the two arrows and the arrow text
  629.       the_scene.gui.larrow.state = 0;
  630.       the_scene.gui.rarrow.state = 0;
  631.       the_scene.gui.arrow_text.is_displayed = false;
  632.    }
  633.  
  634.    // no matter whether the game started or not, if the current player is a human AND its opponent is a computer, allow him to swap sides
  635.    if ((current_player->type == PLAYER_HUMAN) && (opposite_player->type == PLAYER_COMPUTER))
  636.       EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_SWAPSIDES, MF_ENABLED);
  637.    else
  638.       EnableMenuItem (GetMenu (hMainWnd), MENUID_CHESSBOARD_SWAPSIDES, MF_GRAYED);
  639.  
  640.    // update window title
  641.    if ((the_board.players[COLOR_WHITE].name[0] != 0) && (the_board.players[COLOR_BLACK].name[0] != 0))
  642.    {
  643.       swprintf_s (window_title, WCHAR_SIZEOF (window_title), L"%s %s %s - " PROGRAM_NAME L"%s", the_board.players[COLOR_WHITE].name, LOCALIZE (L"Versus"), the_board.players[COLOR_BLACK].name, (is_registered ? L"" : LOCALIZE (L"EvaluationMode")));
  644.       SetWindowText (hMainWnd, window_title); // update window title
  645.    }
  646.    else if (the_board.players[COLOR_WHITE].name[0] != 0)
  647.    {
  648.       swprintf_s (window_title, WCHAR_SIZEOF (window_title), L"%s - " PROGRAM_NAME L"%s", the_board.players[COLOR_WHITE].name, (is_registered ? L"" : LOCALIZE (L"EvaluationMode")));
  649.       SetWindowText (hMainWnd, window_title); // update window title
  650.    }
  651.  
  652.    // are we in internet mode AND are we logged in ?
  653.    if ((network_player != NULL) && network_player->is_logged_in)
  654.    {
  655.       // are we currently playing a game ?
  656.       if (network_player->is_in_game)
  657.       {
  658.          GUIBUTTON_ENABLE (the_scene.gui.chatbutton); // enable chat button if it's not enabled yet
  659.          GUIBUTTON_DISABLE (the_scene.gui.gamesbutton); // disable games button if it was enabled
  660.          GUIBUTTON_DISABLE (the_scene.gui.peoplebutton); // disable people button if it was enabled
  661.          EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_RESIGN, MF_ENABLED); // allow resigning
  662.       }
  663.       else
  664.       {
  665.          GUIBUTTON_DISABLE (the_scene.gui.chatbutton); // disable chat button if it was enabled
  666.          GUIBUTTON_ENABLE (the_scene.gui.gamesbutton); // enable games button if it's not enabled yet
  667.          GUIBUTTON_ENABLE (the_scene.gui.peoplebutton); // enable people button if it's not enabled yet
  668.          EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_RESIGN, MF_GRAYED); // disable ability to resign
  669.       }
  670.       EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_STATISTICS, MF_ENABLED); // enable stats
  671.  
  672.       enabled_value = MF_ENABLED; // remember to enable the internet-related menu items
  673.    }
  674.    // else it's a local or vs. computer game
  675.    else
  676.    {
  677.       GUIBUTTON_DISABLE (the_scene.gui.chatbutton); // disable chat button if it was enabled
  678.       GUIBUTTON_DISABLE (the_scene.gui.gamesbutton); // disable games button if it was enabled
  679.       GUIBUTTON_DISABLE (the_scene.gui.peoplebutton); // disable people button if it was enabled
  680.       EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_RESIGN, MF_ENABLED); // allow resigning
  681.       EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_STATISTICS, MF_GRAYED); // disable stats
  682.  
  683.       enabled_value = MF_GRAYED; // remember to disable the internet-related menu items
  684.    }
  685.  
  686.    EnableMenuItem (GetMenu (hMainWnd), MENUID_GAME_SETUPPOSITION, !enabled_value); // note the inversion
  687.    EnableMenuItem (GetMenu (hMainWnd), MENUID_INTERNET_SHOWONLINEPLAYERS, enabled_value);
  688.    EnableMenuItem (GetMenu (hMainWnd), MENUID_INTERNET_SHOWSOUGHTGAMES, enabled_value);
  689.    EnableMenuItem (GetMenu (hMainWnd), MENUID_INTERNET_SEEKGAME, enabled_value);
  690.    if (!options.network.want_publicchat)
  691.    {
  692.       EnableMenuItem (GetMenu (hMainWnd), MENUID_INTERNET_CHATTERCHANNELS, MF_GRAYED); // always grayed if we don't want public chat
  693.       EnableMenuItem (GetMenu (hMainWnd), MENUID_INTERNET_ENTERCHATTEXT, MF_GRAYED);
  694.    }
  695.    else
  696.    {
  697.       EnableMenuItem (GetMenu (hMainWnd), MENUID_INTERNET_CHATTERCHANNELS, enabled_value); // else enabled only in internet mode
  698.       EnableMenuItem (GetMenu (hMainWnd), MENUID_INTERNET_ENTERCHATTEXT, enabled_value);
  699.    }
  700.    EnableMenuItem (GetMenu (hMainWnd), MENUID_INTERNET_DISPLAYPLAYERCARD, enabled_value);
  701.    EnableMenuItem (GetMenu (hMainWnd), MENUID_INTERNET_DISPLAYYOURCARD, enabled_value);
  702.    EnableMenuItem (GetMenu (hMainWnd), MENUID_INTERNET_MOTD, enabled_value);
  703.  
  704.    the_board.reevaluate = false; // board evaluation has been done
  705.    return; // finished, new board state is known
  706. }
  707.