diff --git a/src/fence_gui.cpp b/src/fence_gui.cpp

index 1e9d178..fbc9718 100644

                lines--;

 

                Recolouring recolouring;

                rect.y += sprite->height;

            }

            break;

diff --git a/src/freerct.cpp b/src/freerct.cpp

index bc093eb..89d57b9 100644

    /* Load RCD files. */

    InitImageStorage();

    _rcd_collection.ScanDirectories();

 

    InitLanguage();

 

    cfg_file.Load("freerct.cfg");

    const char *font_path = cfg_file.GetValue("font", "medium-path");

    int font_size = cfg_file.GetNum("font", "medium-size");

        return 1;

    }

 

    InitMouseModes();

 

    StartNewGame();

diff --git a/src/gui_graphics.cpp b/src/gui_graphics.cpp

index dfa6910..e974ee2 100644

    int xleft = pt.x;

    int ytop = pt.y;

    if (spr_base[WBS_TOP_LEFT] != nullptr) {

        xleft += spr_base[WBS_TOP_LEFT]->xoffset + spr_base[WBS_TOP_LEFT]->width;

        ytop += spr_base[WBS_TOP_LEFT]->yoffset + spr_base[WBS_TOP_LEFT]->height;

    }

    pt.x = rect.base.x + rect.width - 1;

    int xright = pt.x;

    if (spr_base[WBS_TOP_RIGHT] != nullptr) {

        xright += spr_base[WBS_TOP_RIGHT]->xoffset;

    }

 

    pt.y = rect.base.y + rect.height - 1;

    int ybot = pt.y;

    if (spr_base[WBS_BOTTOM_LEFT] != nullptr) {

        ybot += spr_base[WBS_BOTTOM_LEFT]->yoffset;

    }

 

 

    pt.x = rect.base.x + rect.width - 1;

    pt.y = rect.base.y + rect.height - 1;

 

    if (spr_base[WBS_BOTTOM_MIDDLE] != nullptr) _video.BlitHorizontal(xleft, numx, pt.y, spr_base[WBS_BOTTOM_MIDDLE], rc);

 

    r.RestrictTo(0, 0, _video.GetXSize(), _video.GetYSize());

    if (r.width == 0 || r.height == 0) return;

 

    /* Align the disabled sprite so it becomes a continuous pattern. */

    uint16 numx = (r.width + img->width - 1) / img->width;

    uint16 numy = (r.height + img->height - 1) / img->height;

 

    static const Recolouring recolour; // Fixed recolouring mapping.

    _video.BlitImages({base_x, base_y}, img, numx, numy, recolour);

 }

 

 /**

    DrawText(strid, buffer, lengthof(buffer));

    /** \todo Reduce the naiviness of this. */

    if (outline) {

    }

    _video.BlitText(buffer, _palette[colour], x, y, width, align);

 }

diff --git a/src/money.h b/src/money.h

index cf32ff3..a9d54f5 100644

     */

    inline Money& operator+=(const Money& other)

    {

            (this->m_value < 0) == (other.m_value < 0)) {

            this->m_value = (this->m_value < 0) ? INT64_MIN : INT64_MAX ;

        } else {

     */

    inline Money& operator*=(const int factor)

    {

            this->m_value = ((this->m_value < 0) == (factor < 0)) ? INT64_MAX : INT64_MIN;

        } else {

            this->m_value *= factor;

diff --git a/src/palette.h b/src/palette.h

index 42041f4..9c5fd62 100644

 #ifndef PALETTE_H

 #define PALETTE_H

 

 class Random;

 

 extern const uint32 _palette[256];  ///< The 8bpp FreeRCT palette.

    return rgba | opacity;

 }

 

 /** Names of colour ranges. */

 enum ColourRange {

    COL_RANGE_GREY,

 

 /** Shifting of the gradient to make the sprite lighter or darker. */

 enum GradientShift {

    GS_VERY_DARK,      ///< Shift gradient three steps darker.

    GS_DARK,           ///< Shift gradient two steps darker.

    GS_SLIGHTLY_DARK,  ///< Shift gradient one step darker.

    GS_INVALID = 0xff, ///< Invalid gradient shift.

 };

 

 

 /**

  * Get the index of the base colour of a colour range.

diff --git a/src/path_gui.cpp b/src/path_gui.cpp

index 4a0e0ef..d5beca9 100644

                    int dx = (wid->pos.width - path_type_button_size.width) / 2;

                    int dy = (wid->pos.height - path_type_button_size.height) / 2;

                    Point32 pt(GetWidgetScreenX(wid) + dx - path_type_button_size.base.x, GetWidgetScreenY(wid) + dy - path_type_button_size.base.y);

                }

            }

            break;

                    int dx = (wid->pos.width - path_type_button_size.width) / 2;

                    int dy = (wid->pos.height - path_type_button_size.height) / 2;

                    Point32 pt(GetWidgetScreenX(wid) + dx - path_type_button_size.base.x, GetWidgetScreenY(wid) + dy - path_type_button_size.base.y);

                }

            }

            break;

diff --git a/src/ride_gui.cpp b/src/ride_gui.cpp

index f72631d..c007c69 100644

                if (ride_type != nullptr && ride_type->kind == RTK_SHOP) {

                    static const Recolouring recolour; // Never modified, display 'original' image in the GUI.

                    Point32 pt(this->GetWidgetScreenX(wid) + wid->pos.width / 2, this->GetWidgetScreenY(wid) + 40);

                }

            }

            break;

diff --git a/src/sprite_data.cpp b/src/sprite_data.cpp

index d221e5c..113e760 100644

 #include "sprite_data.h"

 #include "fileio.h"

 #include "bitmath.h"

 

 #include <vector>

 

 static const int MAX_IMAGE_COUNT = 5000; ///< Maximum number of images that can be loaded (arbitrary number).

 {

    this->width = 0;

    this->height = 0;

 }

 

 ImageData::~ImageData()

 {

 }

 

 /**

    length -= 8;

    if (length > 100 * 1024) return false; // Another arbitrary limit.

 

 

 

    /* Load jump table, adjusting the entries while loading. */

    for (uint i = 0; i < this->height; i++) {

        uint32 dest = rcd_file->GetUInt32();

        if (dest == 0) {

            continue;

        }

        if (dest >= length) return false;

    }

 

 

    /* Verify the image data. */

    for (uint i = 0; i < this->height; i++) {

        if (offset == INVALID_JUMP) continue;

 

        uint32 xpos = 0;

        for (;;) {

            if (offset + 2 >= length) return false;

            xpos += (rel_pos & 127) + count;

            offset += 2 + count;

            if ((rel_pos & 128) == 0) {

            }

        }

    }

 }

 

 /**

  * Load a 32bpp image.

  * @param rcd_file Input stream to read from.

  * @param length Length of the 32bpp block.

  */

 bool ImageData::Load32bpp(RcdFileReader *rcd_file, size_t length)

 {

    if (length > 100 * 1024) return false; // Another arbitrary limit.

 

    /* Allocate and load the image data. */

 

    /* Verify the data. */

    int line_count = 0;

    bool finished = false;

    while (ptr < abs_end && !finished) {

        line_count++;

    }

    if (line_count != this->height) return false;

    if (ptr != abs_end) return false;

 }

 

 /**

  */

 {

 

                }

            }

        }

            if (mode == 0) break;

                    }

                    }

                }

            }

        }

    }

 }

 

 /**

diff --git a/src/sprite_data.h b/src/sprite_data.h

index e1061b1..778f232 100644

 #ifndef SPRITE_DATA_H

 #define SPRITE_DATA_H

 

 static const uint32 INVALID_JUMP = UINT32_MAX; ///< Invalid jump destination in image data.

 

 class RcdFileReader;

    bool Load8bpp(RcdFileReader *rcd_file, size_t length);

    bool Load32bpp(RcdFileReader *rcd_file, size_t length);

 

 

    /**

     * Is the sprite just a single pixel?

    uint16 height; ///< Height of the image.

    int16 xoffset; ///< Horizontal offset of the image.

    int16 yoffset; ///< Vertical offset of the image.

 };

 

 ImageData *LoadImage(RcdFileReader *rcd_file);

diff --git a/src/terraform_gui.cpp b/src/terraform_gui.cpp

index dbf13a5..5cd5eaf 100644

 

        base.x = this->GetWidgetScreenX(wid) + (wid->pos.width - dot->width) / 2;

        base.y = this->GetWidgetScreenY(wid) + (wid->pos.height - dot->height) / 2;

        return;

    }

 

diff --git a/src/toolbar_gui.cpp b/src/toolbar_gui.cpp

index 57ba0ae..51f49ae 100644

            Viewport *vp = GetViewport();

            int dir = (vp == nullptr) ? 0 : vp->orientation;

            const ImageData *img = _sprite_manager.GetTableSprite(SPR_GUI_COMPASS_START + dir);

            break;

        }

 

        case BTB_WEATHER: {

            int spr = SPR_GUI_WEATHER_START + _weather.GetWeatherType();

            const ImageData *img = _sprite_manager.GetTableSprite(spr);

            break;

        }

    }

diff --git a/src/video.cpp b/src/video.cpp

index f4fbdb2..7ee8601 100644

 #include "gamecontrol.h"

 #include "window.h"

 #include "viewport.h"

 #include <string>

 

 VideoSystem _video;  ///< Video sub-system.

    _finish = true;

 }

 

 /**

  * Default constructor, does nothing, never goes wrong.

  * Call #Initialize to initialize the system.

        return err;

    }

 

    this->GetResolutions();

 

 

    /* SDL_CreateRGBSurfaceFrom() pretends to use a void* for the data,

     * but it's really treated as endian-specific uint32*.

        SDL_SetWindowIcon(this->window, icon);

        SDL_FreeSurface(icon);

    } else {

    }

 

    if (TTF_Init() != 0) {

        SDL_Quit();

        std::string err = "TTF font initialization failed: ";

        err += TTF_GetError();

        return err;

        err += TTF_GetError();

        TTF_Quit();

        SDL_Quit();

        return err;

    }

 

 {

    if (this->initialized && this->GetXSize() == res.x && this->GetYSize() == res.y) return true;

 

    this->vid_width = res.x;

    this->vid_height = res.y;

    SDL_SetWindowSize(this->window, this->vid_width, this->vid_height);

 

    /* Update internal screen size data structures. */

    Viewport *vp = GetViewport();

    if (vp != nullptr) vp->SetSize(this->vid_width, this->vid_height);

    _manager.RepositionAllWindows();

  * Set the clipped area.

  * @param cr New clipped blitting area.

  */

 {

 }

 

 /**

  * Get the current clipped blitting area.

  * @return Current clipped area.

  */

 {

    return this->blit_rect;

 }

 

        if (_finish) break;

 

        uint32 now = SDL_GetTicks();

        if (now >= start) { // No wrap around.

            now -= start;

            if (now < FRAME_DELAY) SDL_Delay(FRAME_DELAY - now); // Too early, wait until next frame.

        TTF_CloseFont(this->font);

        TTF_Quit();

        SDL_Quit();

        this->initialized = false;

        this->dirty = false;

    }

  */

 void VideoSystem::FinishRepaint()

 {

    SDL_RenderPresent(this->renderer);

 

 

 }

 

 /**

  * @param recolour Sprite recolouring definition.

  * @param shift Gradient shift.

  */

 {

    int x_base = pt.x + spr->xoffset;

    int y_base = pt.y + spr->yoffset;

 

 

    }

 

    }

 }

 

 /**

  */

 void VideoSystem::BlitText(const uint8 *text, uint32 colour, int xpos, int ypos, int width, Alignment align)

 {

    SDL_Surface *surf = TTF_RenderUTF8_Solid(this->font, (const char *)text, col);

    if (surf == nullptr) {

        fprintf(stderr, "Rendering text failed (%s)\n", TTF_GetError());

        return;

    }

 

    int real_w = std::min(surf->w, width);

    switch (align) {

        case ALG_LEFT:

            break;

        default: NOT_REACHED();

    }

 

 

    SDL_FreeSurface(surf);

 }

 

  */

 void VideoSystem::DrawLine(const Point16 &start, const Point16 &end, uint32 colour)

 {

 }

 

 /**

  */

 void VideoSystem::DrawRectangle(const Rectangle32 &rect, uint32 colour)

 {

 }

 

 /**

  */

 void VideoSystem::FillRectangle(const Rectangle32 &rect, uint32 colour)

 {

 }

diff --git a/src/video.h b/src/video.h

index 9c9c7ba..d3cfd22 100644

 

 class ImageData;

 

 /** How to align text during drawing. */

 enum Alignment {

    ALG_LEFT,   ///< Align to the left edge.

  * Class representing the video system.

  */

 class VideoSystem {

 public:

    VideoSystem();

    ~VideoSystem();

 

    std::string Initialize(const char *font_name, int font_size);

    bool SetResolution(const Point32 &res);

    void MainLoop();

    void Shutdown();

 

    /**

     * Get horizontal size of the screen.

     * @return Number of pixels of the screen horizontally.

     */

    void MarkDisplayDirty();

    void MarkDisplayDirty(const Rectangle32 &rect);

 

 

    /**

     * Blit a row of sprites.

        this->BlitImages({x, ymin}, spr, 1, numy, recolour);

    }

 

 

    void FinishRepaint();

 

        return this->font_height;

    }

 

    void GetTextSize(const uint8 *text, int *width, int *height);

    void GetNumberRangeSize(int64 smallest, int64 biggest, int *width, int *height);

    void BlitText(const uint8 *text, uint32 colour, int xpos, int ypos, int width = 0x7FFF, Alignment align = ALG_LEFT);

    SDL_Window *window;         ///< %Window of the application.

    SDL_Renderer *renderer;     ///< GPU renderer to the application window.

    SDL_Texture *texture;       ///< GPU Texture storage of the application window.

    Point16 digit_size;         ///< Size of largest digit (initially a zero-size).

 

    bool HandleEvent();

    void MarkDisplayClean();

 };

 

 extern VideoSystem _video;

diff --git a/src/viewport.cpp b/src/viewport.cpp

index 418b901..3a919a6 100644

    collector.Collect(this->additions_enabled && this->additions_displayed);

    static const Recolouring recolour;

 

    for (const auto &iter : collector.draw_images) {

        const DrawData &dd = iter;

        const Recolouring &rec = (dd.recolour == nullptr) ? recolour : *dd.recolour;

    }

 

 }

 

 /**

diff --git a/src/widget.cpp b/src/widget.cpp

index 376677e..619ae9f 100644

        } else if ((this->flags & LWF_PRESSED) != 0) {

            spr_num += WCS_EMPTY_PRESSED;

        }

        return;

    }

 

        int yoffset = top + (bottom - 1 - top - _gui_sprites.close_sprite->height) / 2;

 

        const ImageData *imgdata = _gui_sprites.close_sprite;

        /* Closebox is never shaded. */

    }

 }

            int xoffset = left + (right + 1 - left - this->value_width) / 2 - rect.base.x;

            yoffset -= rect.base.y;

            const ImageData *imgdata = _sprite_manager.GetTableSprite(this->value);

            break;

        }

 

 

            if (imgdata != nullptr) {

                int triangle_yoff = top + (bottom + 1 - top - imgrect.height) / 2 + pressed;

            }

            /* Note: Reusing the same string parameters from above */

            if (this->value != STR_NULL) DrawString(w->TranslateStringNumber(this->value), TEXT_WHITE, left + pressed, yoffset + pressed, right - left - imgrect.width, align);

    Point32 pos(w->GetWidgetScreenX(this), w->GetWidgetScreenY(this));

 

    /* Draw left/up button. */

    if (this->wtype == WT_HOR_SCROLLBAR) pos.x += imd[WLS_LEFT_BUTTON]->width;

    if (this->wtype != WT_HOR_SCROLLBAR) pos.y += imd[WLS_LEFT_BUTTON]->height;

 

    /* Draw top/left underground. */

    if (this->wtype == WT_HOR_SCROLLBAR) pos.x += imd[WLS_LEFT_BED]->width;

    if (this->wtype != WT_HOR_SCROLLBAR) pos.y += imd[WLS_LEFT_BED]->height;

 

    }

 

    /* Draw bottom/right underground. */

    if (this->wtype == WT_HOR_SCROLLBAR) {

        pos.x += imd[WLS_RIGHT_BED]->width;

    } else {

    }

 

    /* Draw right/bottom button. */

 

    int start_edge, slider_length;

    this->CalculateSliderPosition(&start_edge, &slider_length);

    }

 

    /* Draw top/left slider. */

    if (this->wtype == WT_HOR_SCROLLBAR) {

        pos.x += imd[WLS_LEFT_SLIDER]->width;

    } else {

    }

 

    /* Draw bottom/right slider. */

 }

 

 /**

diff --git a/src/window.cpp b/src/window.cpp

index 641e9a4..9aa534e 100644

    /* Until the entire background is covered by the main display, clean the entire display to ensure deleted

     * windows truly disappear (even if there is no other window behind it).

     */

 

    Window *w = _manager.bottom;

    while (w != nullptr) {