src/bootstrap_gui.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file bootstrap_gui.cpp Barely used user interface for bootstrapping OpenTTD, i.e. downloading the required content. */
   9
  10 #include "stdafx.h"
  11 #include "base_media_base.h"
  12 #include "blitter/factory.hpp"
  13 #include "error_func.h"
  14
  15 #if defined(WITH_FREETYPE) || defined(WITH_UNISCRIBE) || defined(WITH_COCOA)
  16
  17 #include "core/geometry_func.hpp"
  18 #include "error.h"
  19 #include "fontcache.h"
  20 #include "gfx_func.h"
  21 #include "network/network.h"
  22 #include "network/network_content_gui.h"
  23 #include "openttd.h"
  24 #include "strings_func.h"
  25 #include "video/video_driver.hpp"
  26 #include "window_func.h"
  27
  28 #include "widgets/bootstrap_widget.h"
  29
  30 #include "table/strings.h"
  31
  32 #include "safeguards.h"
  33
  34 /** Widgets for the background window to prevent smearing. */
  35 static constexpr NWidgetPart _background_widgets[] = {
  36         NWidget(WWT_PANEL, COLOUR_DARK_BLUE, WID_BB_BACKGROUND), SetResize(1, 1),
  37         EndContainer(),
  38 };
  39
  40 /**
  41  * Window description for the background window to prevent smearing.
  42  */
  43 static WindowDesc _background_desc(__FILE__, __LINE__,
  44         WDP_MANUAL, nullptr, 0, 0,
  45         WC_BOOTSTRAP, WC_NONE,
  46         WDF_NO_CLOSE,
  47         std::begin(_background_widgets), std::end(_background_widgets)
  48 );
  49
  50 /** The background for the game. */
  51 class BootstrapBackground : public Window {
  52 public:
  53         BootstrapBackground() : Window(&_background_desc)
  54         {
  55                 this->InitNested(0);
  56                 CLRBITS(this->flags, WF_WHITE_BORDER);
  57                 ResizeWindow(this, _screen.width, _screen.height);
  58         }
  59
  60         void DrawWidget(const Rect &r, WidgetID) const override
  61         {
  62                 GfxFillRect(r.left, r.top, r.right, r.bottom, 4, FILLRECT_OPAQUE);
  63                 GfxFillRect(r.left, r.top, r.right, r.bottom, 0, FILLRECT_CHECKER);
  64         }
  65 };
  66
  67 /** Nested widgets for the error window. */
  68 static constexpr NWidgetPart _nested_bootstrap_errmsg_widgets[] = {
  69         NWidget(NWID_HORIZONTAL),
  70                 NWidget(WWT_CAPTION, COLOUR_GREY, WID_BEM_CAPTION), SetDataTip(STR_MISSING_GRAPHICS_ERROR_TITLE, STR_NULL),
  71         EndContainer(),
  72         NWidget(WWT_PANEL, COLOUR_GREY, WID_BEM_MESSAGE), EndContainer(),
  73         NWidget(NWID_HORIZONTAL),
  74                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BEM_QUIT), SetDataTip(STR_MISSING_GRAPHICS_ERROR_QUIT, STR_NULL), SetFill(1, 0),
  75         EndContainer(),
  76 };
  77
  78 /** Window description for the error window. */
  79 static WindowDesc _bootstrap_errmsg_desc(__FILE__, __LINE__,
  80         WDP_CENTER, nullptr, 0, 0,
  81         WC_BOOTSTRAP, WC_NONE,
  82         WDF_MODAL | WDF_NO_CLOSE,
  83         std::begin(_nested_bootstrap_errmsg_widgets), std::end(_nested_bootstrap_errmsg_widgets)
  84 );
  85
  86 /** The window for a failed bootstrap. */
  87 class BootstrapErrorWindow : public Window {
  88 public:
  89         BootstrapErrorWindow() : Window(&_bootstrap_errmsg_desc)
  90         {
  91                 this->InitNested(1);
  92         }
  93
  94         void Close([[maybe_unused]] int data = 0) override
  95         {
  96                 _exit_game = true;
  97                 this->Window::Close();
  98         }
  99
 100         void UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize) override
 101         {
 102                 if (widget == WID_BEM_MESSAGE) {
 103                         *size = GetStringBoundingBox(STR_MISSING_GRAPHICS_ERROR);
 104                         size->width += WidgetDimensions::scaled.frametext.Horizontal();
 105                         size->height += WidgetDimensions::scaled.frametext.Vertical();
 106                 }
 107         }
 108
 109         void DrawWidget(const Rect &r, WidgetID widget) const override
 110         {
 111                 if (widget == WID_BEM_MESSAGE) {
 112                         DrawStringMultiLine(r.Shrink(WidgetDimensions::scaled.frametext), STR_MISSING_GRAPHICS_ERROR, TC_FROMSTRING, SA_CENTER);
 113                 }
 114         }
 115
 116         void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
 117         {
 118                 if (widget == WID_BEM_QUIT) {
 119                         _exit_game = true;
 120                 }
 121         }
 122 };
 123
 124 /** Nested widgets for the download window. */
 125 static constexpr NWidgetPart _nested_bootstrap_download_status_window_widgets[] = {
 126         NWidget(WWT_CAPTION, COLOUR_GREY), SetDataTip(STR_CONTENT_DOWNLOAD_TITLE, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
 127         NWidget(WWT_PANEL, COLOUR_GREY),
 128                 NWidget(NWID_VERTICAL), SetPIP(0, WidgetDimensions::unscaled.vsep_wide, 0), SetPadding(WidgetDimensions::unscaled.modalpopup),
 129                         NWidget(WWT_EMPTY, INVALID_COLOUR, WID_NCDS_PROGRESS_BAR), SetFill(1, 0),
 130                         NWidget(WWT_EMPTY, INVALID_COLOUR, WID_NCDS_PROGRESS_TEXT), SetFill(1, 0), SetMinimalSize(350, 0),
 131                 EndContainer(),
 132         EndContainer(),
 133 };
 134
 135 /** Window description for the download window */
 136 static WindowDesc _bootstrap_download_status_window_desc(__FILE__, __LINE__,
 137         WDP_CENTER, nullptr, 0, 0,
 138         WC_NETWORK_STATUS_WINDOW, WC_NONE,
 139         WDF_MODAL | WDF_NO_CLOSE,
 140         std::begin(_nested_bootstrap_download_status_window_widgets), std::end(_nested_bootstrap_download_status_window_widgets)
 141 );
 142
 143
 144 /** Window for showing the download status of content */
 145 struct BootstrapContentDownloadStatusWindow : public BaseNetworkContentDownloadStatusWindow {
 146 public:
 147         /** Simple call the constructor of the superclass. */
 148         BootstrapContentDownloadStatusWindow() : BaseNetworkContentDownloadStatusWindow(&_bootstrap_download_status_window_desc)
 149         {
 150         }
 151
 152         void Close([[maybe_unused]] int data = 0) override
 153         {
 154                 /* If we are not set to exit the game, it means the bootstrap failed. */
 155                 if (!_exit_game) {
 156                         new BootstrapErrorWindow();
 157                 }
 158                 this->BaseNetworkContentDownloadStatusWindow::Close();
 159         }
 160
 161         void OnDownloadComplete(ContentID) override
 162         {
 163                 /* We have completed downloading. We can trigger finding the right set now. */
 164                 BaseGraphics::FindSets();
 165
 166                 /* And continue going into the menu. */
 167                 _game_mode = GM_MENU;
 168
 169                 /* _exit_game is used to break out of the outer video driver's MainLoop. */
 170                 _exit_game = true;
 171                 this->Close();
 172         }
 173 };
 174
 175 /** The widgets for the query. It has no close box as that sprite does not exist yet. */
 176 static constexpr NWidgetPart _bootstrap_query_widgets[] = {
 177         NWidget(NWID_HORIZONTAL),
 178                 NWidget(WWT_CAPTION, COLOUR_GREY), SetDataTip(STR_MISSING_GRAPHICS_SET_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
 179         EndContainer(),
 180         NWidget(WWT_PANEL, COLOUR_GREY, WID_BAFD_QUESTION), EndContainer(),
 181         NWidget(NWID_HORIZONTAL),
 182                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BAFD_YES), SetDataTip(STR_MISSING_GRAPHICS_YES_DOWNLOAD, STR_NULL),
 183                 NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_BAFD_NO), SetDataTip(STR_MISSING_GRAPHICS_NO_QUIT, STR_NULL),
 184         EndContainer(),
 185 };
 186
 187 /** The window description for the query. */
 188 static WindowDesc _bootstrap_query_desc(__FILE__, __LINE__,
 189         WDP_CENTER, nullptr, 0, 0,
 190         WC_CONFIRM_POPUP_QUERY, WC_NONE,
 191         WDF_NO_CLOSE,
 192         std::begin(_bootstrap_query_widgets), std::end(_bootstrap_query_widgets)
 193 );
 194
 195 /** The window for the query. It can't use the generic query window as that uses sprites that don't exist yet. */
 196 class BootstrapAskForDownloadWindow : public Window, ContentCallback {
 197         Dimension button_size; ///< The dimension of the button
 198
 199 public:
 200         /** Start listening to the content client events. */
 201         BootstrapAskForDownloadWindow() : Window(&_bootstrap_query_desc)
 202         {
 203                 this->InitNested(WN_CONFIRM_POPUP_QUERY_BOOTSTRAP);
 204                 _network_content_client.AddCallback(this);
 205         }
 206
 207         /** Stop listening to the content client events. */
 208         void Close([[maybe_unused]] int data = 0) override
 209         {
 210                 _network_content_client.RemoveCallback(this);
 211                 this->Window::Close();
 212         }
 213
 214         void UpdateWidgetSize(WidgetID widget, Dimension *size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension *fill, [[maybe_unused]] Dimension *resize) override
 215         {
 216                 /* We cache the button size. This is safe as no reinit can happen here. */
 217                 if (this->button_size.width == 0) {
 218                         this->button_size = maxdim(GetStringBoundingBox(STR_MISSING_GRAPHICS_YES_DOWNLOAD), GetStringBoundingBox(STR_MISSING_GRAPHICS_NO_QUIT));
 219                         this->button_size.width += WidgetDimensions::scaled.frametext.Horizontal();
 220                         this->button_size.height += WidgetDimensions::scaled.frametext.Vertical();
 221                 }
 222
 223                 switch (widget) {
 224                         case WID_BAFD_QUESTION:
 225                                 /* The question is twice as wide as the buttons, and determine the height based on the width. */
 226                                 size->width = this->button_size.width * 2;
 227                                 size->height = GetStringHeight(STR_MISSING_GRAPHICS_SET_MESSAGE, size->width - WidgetDimensions::scaled.frametext.Horizontal()) + WidgetDimensions::scaled.frametext.Vertical();
 228                                 break;
 229
 230                         case WID_BAFD_YES:
 231                         case WID_BAFD_NO:
 232                                 *size = this->button_size;
 233                                 break;
 234                 }
 235         }
 236
 237         void DrawWidget(const Rect &r, WidgetID widget) const override
 238         {
 239                 if (widget != WID_BAFD_QUESTION) return;
 240
 241                 DrawStringMultiLine(r.Shrink(WidgetDimensions::scaled.frametext), STR_MISSING_GRAPHICS_SET_MESSAGE, TC_FROMSTRING, SA_CENTER);
 242         }
 243
 244         void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
 245         {
 246                 switch (widget) {
 247                         case WID_BAFD_YES:
 248                                 /* We got permission to connect! Yay! */
 249                                 _network_content_client.Connect();
 250                                 break;
 251
 252                         case WID_BAFD_NO:
 253                                 _exit_game = true;
 254                                 break;
 255
 256                         default:
 257                                 break;
 258                 }
 259         }
 260
 261         void OnConnect(bool success) override
 262         {
 263                 if (!success) {
 264                         UserError("Failed to connect to content server. Please acquire a graphics set for OpenTTD. See section 1.4 of README.md.");
 265                         /* _exit_game is used to break out of the outer video driver's MainLoop. */
 266                         _exit_game = true;
 267                         this->Close();
 268                         return;
 269                 }
 270
 271                 /* Once connected, request the metadata. */
 272                 _network_content_client.RequestContentList(CONTENT_TYPE_BASE_GRAPHICS);
 273         }
 274
 275         void OnReceiveContentInfo(const ContentInfo *ci) override
 276         {
 277                 /* And once the meta data is received, start downloading it. */
 278                 _network_content_client.Select(ci->id);
 279                 new BootstrapContentDownloadStatusWindow();
 280                 this->Close();
 281         }
 282 };
 283
 284 #endif /* defined(WITH_FREETYPE) */
 285
 286 #if defined(__EMSCRIPTEN__)
 287 #       include <emscripten.h>
 288 #       include "network/network.h"
 289 #       include "network/network_content.h"
 290 #       include "openttd.h"
 291 #       include "video/video_driver.hpp"
 292
 293 class BootstrapEmscripten : public ContentCallback {
 294         bool downloading{false};
 295         uint total_files{0};
 296         uint total_bytes{0};
 297         uint downloaded_bytes{0};
 298
 299 public:
 300         BootstrapEmscripten()
 301         {
 302                 _network_content_client.AddCallback(this);
 303                 _network_content_client.Connect();
 304         }
 305
 306         ~BootstrapEmscripten()
 307         {
 308                 _network_content_client.RemoveCallback(this);
 309         }
 310
 311         void OnConnect(bool success) override
 312         {
 313                 if (!success) {
 314                         EM_ASM({ if (window["openttd_bootstrap_failed"]) openttd_bootstrap_failed(); });
 315                         return;
 316                 }
 317
 318                 /* Once connected, request the metadata. */
 319                 _network_content_client.RequestContentList(CONTENT_TYPE_BASE_GRAPHICS);
 320         }
 321
 322         void OnReceiveContentInfo(const ContentInfo *ci) override
 323         {
 324                 if (this->downloading) return;
 325
 326                 /* And once the metadata is received, start downloading it. */
 327                 _network_content_client.Select(ci->id);
 328                 _network_content_client.DownloadSelectedContent(this->total_files, this->total_bytes);
 329                 this->downloading = true;
 330
 331                 EM_ASM({ if (window["openttd_bootstrap"]) openttd_bootstrap($0, $1); }, this->downloaded_bytes, this->total_bytes);
 332         }
 333
 334         void OnDownloadProgress(const ContentInfo *, int bytes) override
 335         {
 336                 /* A negative value means we are resetting; for example, when retrying or using a fallback. */
 337                 if (bytes < 0) {
 338                         this->downloaded_bytes = 0;
 339                 } else {
 340                         this->downloaded_bytes += bytes;
 341                 }
 342
 343                 EM_ASM({ if (window["openttd_bootstrap"]) openttd_bootstrap($0, $1); }, this->downloaded_bytes, this->total_bytes);
 344         }
 345
 346         void OnDownloadComplete(ContentID) override
 347         {
 348                 /* _exit_game is used to break out of the outer video driver's MainLoop. */
 349                 _exit_game = true;
 350
 351                 delete this;
 352         }
 353 };
 354 #endif /* __EMSCRIPTEN__ */
 355
 356 /**
 357  * Handle all procedures for bootstrapping OpenTTD without a base graphics set.
 358  * This requires all kinds of trickery that is needed to avoid the use of
 359  * sprites from the base graphics set which are pretty interwoven.
 360  * @return True if a base set exists, otherwise false.
 361  */
 362 bool HandleBootstrap()
 363 {
 364         if (BaseGraphics::GetUsedSet() != nullptr) return true;
 365
 366         /* No user interface, bail out with an error. */
 367         if (BlitterFactory::GetCurrentBlitter()->GetScreenDepth() == 0) goto failure;
 368
 369         /* If there is no network or no non-sprite font, then there is nothing we can do. Go straight to failure. */
 370 #if defined(__EMSCRIPTEN__) || (defined(_WIN32) && defined(WITH_UNISCRIBE)) || (defined(WITH_FREETYPE) && (defined(WITH_FONTCONFIG) || defined(__APPLE__))) || defined(WITH_COCOA)
 371         if (!_network_available) goto failure;
 372
 373         /* First tell the game we're bootstrapping. */
 374         _game_mode = GM_BOOTSTRAP;
 375
 376 #if defined(__EMSCRIPTEN__)
 377         new BootstrapEmscripten();
 378 #else
 379         /* Initialise the font cache. */
 380         InitializeUnicodeGlyphMap();
 381         /* Next "force" finding a suitable non-sprite font as the local font is missing. */
 382         CheckForMissingGlyphs(false);
 383
 384         /* Initialise the palette. The biggest step is 'faking' some recolour sprites.
 385          * This way the mauve and gray colours work and we can show the user interface. */
 386         GfxInitPalettes();
 387         static const int offsets[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x80, 0, 0, 0, 0x04, 0x08 };
 388         for (uint i = 0; i != 16; i++) {
 389                 for (int j = 0; j < 8; j++) {
 390                         _colour_gradient[i][j] = offsets[i] + j;
 391                 }
 392         }
 393
 394         /* Finally ask the question. */
 395         new BootstrapBackground();
 396         new BootstrapAskForDownloadWindow();
 397 #endif /* __EMSCRIPTEN__ */
 398
 399         /* Process the user events. */
 400         VideoDriver::GetInstance()->MainLoop();
 401
 402         /* _exit_game is used to get out of the video driver's main loop.
 403          * In case GM_BOOTSTRAP is still set we did not exit it via the
 404          * "download complete" event, so it was a manual exit. Obey it. */
 405         _exit_game = _game_mode == GM_BOOTSTRAP;
 406         if (_exit_game) return false;
 407
 408         /* Try to probe the graphics. Should work this time. */
 409         if (!BaseGraphics::SetSet({})) goto failure;
 410
 411         /* Finally we can continue heading for the menu. */
 412         _game_mode = GM_MENU;
 413         return true;
 414 #endif
 415
 416         /* Failure to get enough working to get a graphics set. */
 417 failure:
 418         UserError("Failed to find a graphics set. Please acquire a graphics set for OpenTTD. See section 1.4 of README.md.");
 419         return false;
 420 }