mirror of https://github.com/OpenRCT2/OpenRCT2.git
1940 lines
60 KiB
C++
1940 lines
60 KiB
C++
/*****************************************************************************
|
|
* Copyright (c) 2014-2023 OpenRCT2 developers
|
|
*
|
|
* For a complete list of all authors, please refer to contributors.md
|
|
* Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2
|
|
*
|
|
* OpenRCT2 is licensed under the GNU General Public License version 3.
|
|
*****************************************************************************/
|
|
|
|
#include <array>
|
|
#include <openrct2-ui/interface/Dropdown.h>
|
|
#include <openrct2-ui/interface/Viewport.h>
|
|
#include <openrct2-ui/interface/Widget.h>
|
|
#include <openrct2-ui/windows/Window.h>
|
|
#include <openrct2/Context.h>
|
|
#include <openrct2/Game.h>
|
|
#include <openrct2/GameState.h>
|
|
#include <openrct2/Input.h>
|
|
#include <openrct2/actions/GuestSetFlagsAction.h>
|
|
#include <openrct2/actions/GuestSetNameAction.h>
|
|
#include <openrct2/actions/PeepPickupAction.h>
|
|
#include <openrct2/config/Config.h>
|
|
#include <openrct2/entity/Guest.h>
|
|
#include <openrct2/entity/Staff.h>
|
|
#include <openrct2/localisation/Formatter.h>
|
|
#include <openrct2/localisation/Formatting.h>
|
|
#include <openrct2/localisation/Localisation.h>
|
|
#include <openrct2/management/Marketing.h>
|
|
#include <openrct2/network/network.h>
|
|
#include <openrct2/ride/RideData.h>
|
|
#include <openrct2/ride/ShopItem.h>
|
|
#include <openrct2/scenario/Scenario.h>
|
|
#include <openrct2/sprites.h>
|
|
#include <openrct2/util/Util.h>
|
|
#include <openrct2/windows/Intent.h>
|
|
#include <openrct2/world/Footpath.h>
|
|
#include <openrct2/world/Park.h>
|
|
|
|
static constexpr const StringId WINDOW_TITLE = STR_STRINGID;
|
|
static constexpr const int32_t WH = 157;
|
|
static constexpr const int32_t WW = 192;
|
|
|
|
enum WindowGuestPage
|
|
{
|
|
WINDOW_GUEST_OVERVIEW,
|
|
WINDOW_GUEST_STATS,
|
|
WINDOW_GUEST_RIDES,
|
|
WINDOW_GUEST_FINANCE,
|
|
WINDOW_GUEST_THOUGHTS,
|
|
WINDOW_GUEST_INVENTORY,
|
|
WINDOW_GUEST_DEBUG,
|
|
WINDOW_GUEST_PAGE_COUNT,
|
|
};
|
|
|
|
enum WindowGuestWidgetIdx
|
|
{
|
|
WIDX_BACKGROUND,
|
|
WIDX_TITLE,
|
|
WIDX_CLOSE,
|
|
WIDX_PAGE_BACKGROUND,
|
|
WIDX_TAB_1,
|
|
WIDX_TAB_2,
|
|
WIDX_TAB_3,
|
|
WIDX_TAB_4,
|
|
WIDX_TAB_5,
|
|
WIDX_TAB_6,
|
|
WIDX_TAB_7,
|
|
|
|
WIDX_MARQUEE = 11,
|
|
WIDX_VIEWPORT,
|
|
WIDX_ACTION_LBL,
|
|
WIDX_PICKUP,
|
|
WIDX_RENAME,
|
|
WIDX_LOCATE,
|
|
WIDX_TRACK,
|
|
|
|
WIDX_RIDE_SCROLL = 11
|
|
};
|
|
|
|
validate_global_widx(WC_PEEP, WIDX_PICKUP);
|
|
|
|
static constexpr int32_t TabWidth = 30;
|
|
|
|
#define MAIN_GUEST_WIDGETS \
|
|
WINDOW_SHIM(WINDOW_TITLE, WW, WH), \
|
|
MakeWidget({ 0, 43 }, { 192, 114 }, WindowWidgetType::Resize, WindowColour::Secondary), /* Resize */ \
|
|
MakeTab({ 3, 17 }, STR_SHOW_GUEST_VIEW_TIP), /* Tab 1 */ \
|
|
MakeTab({ 34, 17 }, STR_SHOW_GUEST_NEEDS_TIP), /* Tab 2 */ \
|
|
MakeTab({ 65, 17 }, STR_SHOW_GUEST_VISITED_RIDES_TIP), /* Tab 3 */ \
|
|
MakeTab({ 96, 17 }, STR_SHOW_GUEST_FINANCE_TIP), /* Tab 4 */ \
|
|
MakeTab({ 127, 17 }, STR_SHOW_GUEST_THOUGHTS_TIP), /* Tab 5 */ \
|
|
MakeTab({ 158, 17 }, STR_SHOW_GUEST_ITEMS_TIP), /* Tab 6 */ \
|
|
MakeTab({ 189, 17 }, STR_DEBUG_TIP) /* Tab 7 */
|
|
|
|
// clang-format off
|
|
static Widget _guestWindowWidgetsOverview[] = {
|
|
MAIN_GUEST_WIDGETS,
|
|
MakeWidget({ 3, 45}, {164, 12}, WindowWidgetType::LabelCentred, WindowColour::Secondary ), // Label Thought marquee
|
|
MakeWidget({ 3, 57}, {164, 87}, WindowWidgetType::Viewport, WindowColour::Secondary ), // Viewport
|
|
MakeWidget({ 3, 144}, {164, 11}, WindowWidgetType::LabelCentred, WindowColour::Secondary ), // Label Action
|
|
MakeWidget({167, 45}, { 24, 24}, WindowWidgetType::FlatBtn, WindowColour::Secondary, ImageId(SPR_PICKUP_BTN), STR_PICKUP_TIP ), // Pickup Button
|
|
MakeWidget({167, 69}, { 24, 24}, WindowWidgetType::FlatBtn, WindowColour::Secondary, ImageId(SPR_RENAME), STR_NAME_GUEST_TIP ), // Rename Button
|
|
MakeWidget({167, 93}, { 24, 24}, WindowWidgetType::FlatBtn, WindowColour::Secondary, ImageId(SPR_LOCATE), STR_LOCATE_SUBJECT_TIP ), // Locate Button
|
|
MakeWidget({167, 117}, { 24, 24}, WindowWidgetType::FlatBtn, WindowColour::Secondary, ImageId(SPR_TRACK_PEEP), STR_TOGGLE_GUEST_TRACKING_TIP), // Track Button
|
|
WIDGETS_END,
|
|
};
|
|
// clang-format on
|
|
|
|
static Widget _guestWindowWidgetsStats[] = {
|
|
MAIN_GUEST_WIDGETS,
|
|
WIDGETS_END,
|
|
};
|
|
|
|
static Widget _guestWindowWidgetsRides[] = {
|
|
MAIN_GUEST_WIDGETS,
|
|
MakeWidget({ 3, 57 }, { 186, 87 }, WindowWidgetType::Scroll, WindowColour::Secondary, SCROLL_VERTICAL),
|
|
WIDGETS_END,
|
|
};
|
|
|
|
static Widget _guestWindowWidgetsFinance[] = {
|
|
MAIN_GUEST_WIDGETS,
|
|
WIDGETS_END,
|
|
};
|
|
|
|
static Widget _guestWindowWidgetsThoughts[] = {
|
|
MAIN_GUEST_WIDGETS,
|
|
WIDGETS_END,
|
|
};
|
|
|
|
static Widget _guestWindowWidgetsInventory[] = {
|
|
MAIN_GUEST_WIDGETS,
|
|
WIDGETS_END,
|
|
};
|
|
|
|
static Widget _guestWindowWidgetsDebug[] = {
|
|
MAIN_GUEST_WIDGETS,
|
|
WIDGETS_END,
|
|
};
|
|
|
|
// clang-format off
|
|
static constexpr std::array _guestWindowPageWidgets = {
|
|
_guestWindowWidgetsOverview,
|
|
_guestWindowWidgetsStats,
|
|
_guestWindowWidgetsRides,
|
|
_guestWindowWidgetsFinance,
|
|
_guestWindowWidgetsThoughts,
|
|
_guestWindowWidgetsInventory,
|
|
_guestWindowWidgetsDebug,
|
|
};
|
|
static_assert(_guestWindowPageWidgets.size() == WINDOW_GUEST_PAGE_COUNT);
|
|
// clang-format on
|
|
|
|
static constexpr const std::array _guestWindowPageSizes = {
|
|
std::array{ ScreenSize{ 192, 159 }, ScreenSize{ 500, 450 } }, // WINDOW_GUEST_OVERVIEW
|
|
std::array{ ScreenSize{ 192, 180 }, ScreenSize{ 192, 180 } }, // WINDOW_GUEST_STATS
|
|
std::array{ ScreenSize{ 192, 180 }, ScreenSize{ 500, 400 } }, // WINDOW_GUEST_RIDES
|
|
std::array{ ScreenSize{ 210, 148 }, ScreenSize{ 210, 148 } }, // WINDOW_GUEST_FINANCE
|
|
std::array{ ScreenSize{ 192, 159 }, ScreenSize{ 500, 450 } }, // WINDOW_GUEST_THOUGHTS
|
|
std::array{ ScreenSize{ 192, 159 }, ScreenSize{ 500, 450 } }, // WINDOW_GUEST_INVENTORY
|
|
std::array{ ScreenSize{ 192, 171 }, ScreenSize{ 192, 171 } }, // WINDOW_GUEST_DEBUG
|
|
};
|
|
static_assert(_guestWindowPageSizes.size() == WINDOW_GUEST_PAGE_COUNT);
|
|
|
|
class GuestWindow final : public Window
|
|
{
|
|
private:
|
|
uint16_t _marqueePosition = 0;
|
|
uint16_t _beingWatchedTimer = 0;
|
|
uint16_t _guestAnimationFrame = 0;
|
|
int16_t _pickedPeepX = LOCATION_NULL; // entity->x gets set to 0x8000 on pickup, this is the old value
|
|
|
|
public:
|
|
void OnOpen() override
|
|
{
|
|
widgets = _guestWindowWidgetsOverview;
|
|
page = WINDOW_GUEST_OVERVIEW;
|
|
frame_no = 0;
|
|
_marqueePosition = 0;
|
|
picked_peep_frame = 0;
|
|
min_width = width;
|
|
min_height = 157;
|
|
max_width = 500;
|
|
max_height = 450;
|
|
no_list_items = 0;
|
|
selected_list_item = -1;
|
|
}
|
|
|
|
void Init(EntityId id)
|
|
{
|
|
number = id.ToUnderlying();
|
|
page = -1; // Set Page to something invalid so that SetPage doesn't set audio on viewport
|
|
SetPage(WINDOW_GUEST_OVERVIEW);
|
|
}
|
|
|
|
void OnClose() override
|
|
{
|
|
if (InputTestFlag(INPUT_FLAG_TOOL_ACTIVE))
|
|
{
|
|
if (classification == gCurrentToolWidget.window_classification && number == gCurrentToolWidget.window_number)
|
|
ToolCancel();
|
|
}
|
|
}
|
|
|
|
void OnMouseUp(WidgetIndex widx) override
|
|
{
|
|
switch (widx)
|
|
{
|
|
case WIDX_CLOSE:
|
|
Close();
|
|
return;
|
|
case WIDX_TAB_1:
|
|
case WIDX_TAB_2:
|
|
case WIDX_TAB_3:
|
|
case WIDX_TAB_4:
|
|
case WIDX_TAB_5:
|
|
case WIDX_TAB_6:
|
|
case WIDX_TAB_7:
|
|
SetPage(widx - WIDX_TAB_1);
|
|
return;
|
|
}
|
|
|
|
switch (page)
|
|
{
|
|
case WINDOW_GUEST_OVERVIEW:
|
|
OnMouseUpOverview(widx);
|
|
break;
|
|
}
|
|
}
|
|
void OnMouseDown(WidgetIndex widx) override
|
|
{
|
|
if (page == WINDOW_GUEST_OVERVIEW)
|
|
{
|
|
OnMouseDownOverview(widx);
|
|
}
|
|
}
|
|
void OnDropdown(WidgetIndex widgetIndex, int32_t selectedIndex) override
|
|
{
|
|
if (page == WINDOW_GUEST_OVERVIEW)
|
|
{
|
|
OnDropdownOverview(widgetIndex, selectedIndex);
|
|
}
|
|
}
|
|
void OnResize() override
|
|
{
|
|
switch (page)
|
|
{
|
|
case WINDOW_GUEST_OVERVIEW:
|
|
OnResizeOverview();
|
|
break;
|
|
case WINDOW_GUEST_STATS:
|
|
case WINDOW_GUEST_RIDES:
|
|
case WINDOW_GUEST_FINANCE:
|
|
case WINDOW_GUEST_THOUGHTS:
|
|
case WINDOW_GUEST_INVENTORY:
|
|
case WINDOW_GUEST_DEBUG:
|
|
OnResizeCommon();
|
|
break;
|
|
}
|
|
}
|
|
void OnUpdate() override
|
|
{
|
|
switch (page)
|
|
{
|
|
case WINDOW_GUEST_OVERVIEW:
|
|
OnUpdateOverview();
|
|
break;
|
|
case WINDOW_GUEST_STATS:
|
|
OnUpdateStats();
|
|
break;
|
|
case WINDOW_GUEST_RIDES:
|
|
OnUpdateRides();
|
|
break;
|
|
case WINDOW_GUEST_FINANCE:
|
|
OnUpdateFinance();
|
|
break;
|
|
case WINDOW_GUEST_THOUGHTS:
|
|
OnUpdateThoughts();
|
|
break;
|
|
case WINDOW_GUEST_INVENTORY:
|
|
OnUpdateInventory();
|
|
break;
|
|
case WINDOW_GUEST_DEBUG:
|
|
OnUpdateDebug();
|
|
break;
|
|
}
|
|
}
|
|
void OnToolUpdate(WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords) override
|
|
{
|
|
if (page == WINDOW_GUEST_OVERVIEW)
|
|
{
|
|
OnToolUpdateOverview(widgetIndex, screenCoords);
|
|
}
|
|
}
|
|
void OnToolDown(WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords) override
|
|
{
|
|
if (page == WINDOW_GUEST_OVERVIEW)
|
|
{
|
|
OnToolDownOverview(widgetIndex, screenCoords);
|
|
}
|
|
}
|
|
void OnToolAbort(WidgetIndex widgetIndex) override
|
|
{
|
|
if (page == WINDOW_GUEST_OVERVIEW)
|
|
{
|
|
OnToolAbortOverview(widgetIndex);
|
|
}
|
|
}
|
|
void OnTextInput(WidgetIndex widgetIndex, std::string_view text) override
|
|
{
|
|
if (page == WINDOW_GUEST_OVERVIEW)
|
|
{
|
|
OnTextInputOverview(widgetIndex, text);
|
|
}
|
|
}
|
|
void OnViewportRotate() override
|
|
{
|
|
if (page == WINDOW_GUEST_OVERVIEW)
|
|
{
|
|
OnViewportRotateOverview();
|
|
}
|
|
}
|
|
void OnDraw(DrawPixelInfo& dpi) override
|
|
{
|
|
switch (page)
|
|
{
|
|
case WINDOW_GUEST_OVERVIEW:
|
|
OnDrawOverview(dpi);
|
|
break;
|
|
case WINDOW_GUEST_STATS:
|
|
OnDrawStats(dpi);
|
|
break;
|
|
case WINDOW_GUEST_RIDES:
|
|
OnDrawRides(dpi);
|
|
break;
|
|
case WINDOW_GUEST_FINANCE:
|
|
OnDrawFinance(dpi);
|
|
break;
|
|
case WINDOW_GUEST_THOUGHTS:
|
|
OnDrawThoughts(dpi);
|
|
break;
|
|
case WINDOW_GUEST_INVENTORY:
|
|
OnDrawInventory(dpi);
|
|
break;
|
|
case WINDOW_GUEST_DEBUG:
|
|
OnDrawDebug(dpi);
|
|
break;
|
|
}
|
|
}
|
|
void OnPrepareDraw() override
|
|
{
|
|
OnPrepareDrawCommon();
|
|
switch (page)
|
|
{
|
|
case WINDOW_GUEST_OVERVIEW:
|
|
OnPrepareDrawOverview();
|
|
break;
|
|
case WINDOW_GUEST_RIDES:
|
|
OnPrepareDrawRides();
|
|
break;
|
|
}
|
|
}
|
|
ScreenSize OnScrollGetSize(int32_t scrollIndex) override
|
|
{
|
|
if (page == WINDOW_GUEST_RIDES)
|
|
{
|
|
return OnScrollGetSizeRides(scrollIndex);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
void OnScrollMouseOver(int32_t scrollIndex, const ScreenCoordsXY& screenCoords) override
|
|
{
|
|
if (page == WINDOW_GUEST_RIDES)
|
|
{
|
|
OnScrollMouseOverRides(scrollIndex, screenCoords);
|
|
}
|
|
}
|
|
void OnScrollMouseDown(int32_t scrollIndex, const ScreenCoordsXY& screenCoords) override
|
|
{
|
|
if (page == WINDOW_GUEST_RIDES)
|
|
{
|
|
OnScrollMouseDownRides(scrollIndex, screenCoords);
|
|
}
|
|
}
|
|
void OnScrollDraw(int32_t scrollIndex, DrawPixelInfo& dpi) override
|
|
{
|
|
if (page == WINDOW_GUEST_RIDES)
|
|
{
|
|
OnScrollDrawRides(scrollIndex, dpi);
|
|
}
|
|
}
|
|
|
|
private:
|
|
Guest* GetGuest()
|
|
{
|
|
auto guest = GetEntity<Guest>(EntityId::FromUnderlying(number));
|
|
if (guest == nullptr)
|
|
{
|
|
Close();
|
|
return nullptr;
|
|
}
|
|
return guest;
|
|
}
|
|
|
|
void OnResizeCommon()
|
|
{
|
|
// Get page specific min and max size
|
|
int32_t minWidth = _guestWindowPageSizes[page][0].width;
|
|
int32_t minHeight = _guestWindowPageSizes[page][0].height;
|
|
int32_t maxWidth = _guestWindowPageSizes[page][1].width;
|
|
int32_t maxHeight = _guestWindowPageSizes[page][1].height;
|
|
|
|
// Ensure min size is large enough for all tabs to fit
|
|
for (int32_t i = WIDX_TAB_1; i <= WIDX_TAB_7; i++)
|
|
{
|
|
if (!WidgetIsDisabled(*this, i))
|
|
{
|
|
minWidth = std::max(minWidth, widgets[i].right + 3);
|
|
}
|
|
}
|
|
maxWidth = std::max(minWidth, maxWidth);
|
|
|
|
WindowSetResize(*this, minWidth, minHeight, maxWidth, maxHeight);
|
|
}
|
|
|
|
void OnPrepareDrawCommon()
|
|
{
|
|
if (_guestWindowPageWidgets[page] != widgets)
|
|
{
|
|
widgets = _guestWindowPageWidgets[page];
|
|
InitScrollWidgets();
|
|
}
|
|
|
|
pressed_widgets |= 1uLL << (page + WIDX_TAB_1);
|
|
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
auto ft = Formatter::Common();
|
|
peep->FormatNameTo(ft);
|
|
|
|
ResizeFrameWithPage();
|
|
|
|
WindowAlignTabs(this, WIDX_TAB_1, WIDX_TAB_7);
|
|
}
|
|
|
|
void DisableWidgets()
|
|
{
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
uint64_t newDisabledWidgets = 0;
|
|
|
|
if (peep->CanBePickedUp())
|
|
{
|
|
if (WidgetIsDisabled(*this, WIDX_PICKUP))
|
|
Invalidate();
|
|
}
|
|
else
|
|
{
|
|
newDisabledWidgets = (1uLL << WIDX_PICKUP);
|
|
if (!WidgetIsDisabled(*this, WIDX_PICKUP))
|
|
Invalidate();
|
|
}
|
|
if (gParkFlags & PARK_FLAGS_NO_MONEY)
|
|
{
|
|
newDisabledWidgets |= (1uLL << WIDX_TAB_4); // Disable finance tab if no money
|
|
}
|
|
if (!gConfigGeneral.DebuggingTools)
|
|
{
|
|
newDisabledWidgets |= (1uLL << WIDX_TAB_7); // Disable debug tab when debug tools not turned on
|
|
}
|
|
disabled_widgets = newDisabledWidgets;
|
|
}
|
|
|
|
void SetPage(int32_t newPage)
|
|
{
|
|
if (InputTestFlag(INPUT_FLAG_TOOL_ACTIVE))
|
|
{
|
|
if (number == gCurrentToolWidget.window_number && classification == gCurrentToolWidget.window_classification)
|
|
ToolCancel();
|
|
}
|
|
int32_t listen = 0;
|
|
if (newPage == WINDOW_GUEST_OVERVIEW && page == WINDOW_GUEST_OVERVIEW && viewport != nullptr)
|
|
{
|
|
if (!(viewport->flags & VIEWPORT_FLAG_SOUND_ON))
|
|
listen = 1;
|
|
}
|
|
|
|
page = newPage;
|
|
frame_no = 0;
|
|
no_list_items = 0;
|
|
selected_list_item = -1;
|
|
|
|
RemoveViewport();
|
|
|
|
hold_down_widgets = 0;
|
|
pressed_widgets = 0;
|
|
widgets = _guestWindowPageWidgets[page];
|
|
DisableWidgets();
|
|
Invalidate();
|
|
OnResize();
|
|
OnPrepareDraw();
|
|
InitScrollWidgets();
|
|
Invalidate();
|
|
|
|
if (listen && viewport != nullptr)
|
|
viewport->flags |= VIEWPORT_FLAG_SOUND_ON;
|
|
}
|
|
|
|
#pragma region Overview
|
|
|
|
void OverviewTabDraw(DrawPixelInfo& dpi)
|
|
{
|
|
if (WidgetIsDisabled(*this, WIDX_TAB_1))
|
|
return;
|
|
|
|
const auto& widget = widgets[WIDX_TAB_1];
|
|
int32_t widgWidth = widget.width() - 1;
|
|
int32_t widgHeight = widget.height() - 1;
|
|
auto screenCoords = windowPos + ScreenCoordsXY{ widget.left + 1, widget.top + 1 };
|
|
if (page == WINDOW_GUEST_OVERVIEW)
|
|
widgHeight++;
|
|
|
|
DrawPixelInfo clipDpi;
|
|
if (!ClipDrawPixelInfo(&clipDpi, &dpi, screenCoords, widgWidth, widgHeight))
|
|
{
|
|
return;
|
|
}
|
|
|
|
screenCoords = ScreenCoordsXY{ 14, 20 };
|
|
|
|
const auto* peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int32_t animationFrame = GetPeepAnimation(peep->SpriteType).base_image + 1;
|
|
|
|
int32_t animationFrameOffset = 0;
|
|
|
|
if (page == WINDOW_GUEST_OVERVIEW)
|
|
{
|
|
animationFrameOffset = _guestAnimationFrame;
|
|
animationFrameOffset &= 0xFFFC;
|
|
}
|
|
animationFrame += animationFrameOffset;
|
|
|
|
auto spriteId = ImageId(animationFrame, peep->TshirtColour, peep->TrousersColour);
|
|
GfxDrawSprite(&clipDpi, spriteId, screenCoords);
|
|
|
|
auto* guest = peep->As<Guest>();
|
|
if (guest != nullptr)
|
|
{
|
|
// If holding a balloon
|
|
if (animationFrame >= 0x2A1D && animationFrame < 0x2A3D)
|
|
{
|
|
GfxDrawSprite(&clipDpi, ImageId(animationFrame + 32, guest->BalloonColour), screenCoords);
|
|
}
|
|
|
|
// If holding umbrella
|
|
if (animationFrame >= 0x2BBD && animationFrame < 0x2BDD)
|
|
{
|
|
GfxDrawSprite(&clipDpi, ImageId(animationFrame + 32, guest->UmbrellaColour), screenCoords);
|
|
}
|
|
|
|
// If wearing hat
|
|
if (animationFrame >= 0x29DD && animationFrame < 0x29FD)
|
|
{
|
|
GfxDrawSprite(&clipDpi, ImageId(animationFrame + 32, guest->HatColour), screenCoords);
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnResizeOverview()
|
|
{
|
|
DisableWidgets();
|
|
OnPrepareDraw();
|
|
|
|
WidgetInvalidate(*this, WIDX_MARQUEE);
|
|
|
|
OnResizeCommon();
|
|
|
|
if (viewport != nullptr)
|
|
{
|
|
auto reqViewportWidth = width - 30;
|
|
auto reqViewportHeight = height - 72;
|
|
if (viewport->width != reqViewportWidth || viewport->height != reqViewportHeight)
|
|
{
|
|
viewport->width = reqViewportWidth;
|
|
viewport->height = reqViewportHeight;
|
|
viewport->view_width = viewport->zoom.ApplyInversedTo(viewport->width);
|
|
viewport->view_height = viewport->zoom.ApplyInversedTo(viewport->height);
|
|
}
|
|
}
|
|
OnViewportRotate();
|
|
}
|
|
|
|
void OnMouseUpOverview(WidgetIndex widgetIndex)
|
|
{
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch (widgetIndex)
|
|
{
|
|
case WIDX_PICKUP:
|
|
{
|
|
if (!peep->CanBePickedUp())
|
|
{
|
|
return;
|
|
}
|
|
_pickedPeepX = peep->x;
|
|
CoordsXYZ nullLoc{};
|
|
nullLoc.SetNull();
|
|
PeepPickupAction pickupAction{ PeepPickupType::Pickup, EntityId::FromUnderlying(number), nullLoc,
|
|
NetworkGetCurrentPlayerId() };
|
|
pickupAction.SetCallback([peepnum = number](const GameAction* ga, const GameActions::Result* result) {
|
|
if (result->Error != GameActions::Status::Ok)
|
|
return;
|
|
WindowBase* wind = WindowFindByNumber(WindowClass::Peep, peepnum);
|
|
if (wind != nullptr)
|
|
{
|
|
ToolSet(*wind, WC_PEEP__WIDX_PICKUP, Tool::Picker);
|
|
}
|
|
});
|
|
GameActions::Execute(&pickupAction);
|
|
}
|
|
break;
|
|
case WIDX_RENAME:
|
|
{
|
|
auto peepName = peep->GetName();
|
|
WindowTextInputRawOpen(
|
|
this, widgetIndex, STR_GUEST_RENAME_TITLE, STR_GUEST_RENAME_PROMPT, {}, peepName.c_str(), 32);
|
|
break;
|
|
}
|
|
case WIDX_TRACK:
|
|
{
|
|
uint32_t guestFlags = peep->PeepFlags ^ PEEP_FLAGS_TRACKING;
|
|
|
|
auto guestSetFlagsAction = GuestSetFlagsAction(EntityId::FromUnderlying(number), guestFlags);
|
|
GameActions::Execute(&guestSetFlagsAction);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OnMouseDownOverview(WidgetIndex widgetIndex)
|
|
{
|
|
switch (widgetIndex)
|
|
{
|
|
case WIDX_LOCATE:
|
|
ShowLocateDropdown(widgets[widgetIndex]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OnDropdownOverview(WidgetIndex widgetIndex, int32_t dropdownIndex)
|
|
{
|
|
switch (widgetIndex)
|
|
{
|
|
case WIDX_LOCATE:
|
|
{
|
|
if (dropdownIndex == 0)
|
|
{
|
|
ScrollToViewport();
|
|
}
|
|
else if (dropdownIndex == 1)
|
|
{
|
|
GuestFollow();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ShowLocateDropdown(Widget& widget)
|
|
{
|
|
gDropdownItems[0].Format = STR_LOCATE_SUBJECT_TIP;
|
|
gDropdownItems[1].Format = STR_FOLLOW_SUBJECT_TIP;
|
|
|
|
WindowDropdownShowText({ windowPos.x + widget.left, windowPos.y + widget.top }, widget.height() + 1, colours[1], 0, 2);
|
|
gDropdownDefaultIndex = 0;
|
|
}
|
|
|
|
void GuestFollow()
|
|
{
|
|
WindowBase* main = WindowGetMain();
|
|
WindowFollowSprite(*main, EntityId::FromUnderlying(number));
|
|
}
|
|
|
|
void OnViewportRotateOverview()
|
|
{
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ViewportUpdateSmartFollowGuest(this, peep);
|
|
bool reCreateViewport = false;
|
|
uint16_t origViewportFlags{};
|
|
if (viewport != nullptr)
|
|
{
|
|
if (focus.has_value())
|
|
return;
|
|
|
|
origViewportFlags = viewport->flags;
|
|
|
|
reCreateViewport = true;
|
|
RemoveViewport();
|
|
}
|
|
|
|
OnPrepareDraw();
|
|
|
|
if (peep->State != PeepState::Picked && viewport == nullptr)
|
|
{
|
|
const auto& viewWidget = widgets[WIDX_VIEWPORT];
|
|
auto screenPos = ScreenCoordsXY{ viewWidget.left + 1 + windowPos.x, viewWidget.top + 1 + windowPos.y };
|
|
int32_t widgWidth = viewWidget.width() - 1;
|
|
int32_t widgHeight = viewWidget.height() - 1;
|
|
|
|
ViewportCreate(this, screenPos, widgWidth, widgHeight, focus.value());
|
|
if (viewport != nullptr && reCreateViewport)
|
|
{
|
|
viewport->flags = origViewportFlags;
|
|
}
|
|
flags |= WF_NO_SCROLLING;
|
|
Invalidate();
|
|
}
|
|
Invalidate();
|
|
}
|
|
|
|
void OnDrawOverview(DrawPixelInfo& dpi)
|
|
{
|
|
DrawWidgets(dpi);
|
|
OverviewTabDraw(dpi);
|
|
StatsTabDraw(dpi);
|
|
RidesTabDraw(dpi);
|
|
FinanceTabDraw(dpi);
|
|
ThoughtsTabDraw(dpi);
|
|
InventoryTabDraw(dpi);
|
|
DebugTabDraw(dpi);
|
|
|
|
// Draw the viewport no sound sprite
|
|
if (viewport != nullptr)
|
|
{
|
|
WindowDrawViewport(&dpi, *this);
|
|
if (viewport->flags & VIEWPORT_FLAG_SOUND_ON)
|
|
{
|
|
GfxDrawSprite(&dpi, ImageId(SPR_HEARING_VIEWPORT), windowPos + ScreenCoordsXY{ 2, 2 });
|
|
}
|
|
}
|
|
|
|
// Draw the centred label
|
|
const auto* peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const auto& actionLabelWidget = widgets[WIDX_ACTION_LBL];
|
|
auto screenPos = windowPos + ScreenCoordsXY{ actionLabelWidget.midX(), actionLabelWidget.top - 1 };
|
|
|
|
{
|
|
auto ft = Formatter();
|
|
peep->FormatActionTo(ft);
|
|
int32_t textWidth = actionLabelWidget.width();
|
|
DrawTextEllipsised(dpi, screenPos, textWidth, STR_BLACK_STRING, ft, { TextAlignment::CENTRE });
|
|
}
|
|
|
|
// Draw the marquee thought
|
|
const auto& marqueeWidget = widgets[WIDX_MARQUEE];
|
|
auto marqWidth = marqueeWidget.width() - 3;
|
|
int32_t left = marqueeWidget.left + 2 + windowPos.x;
|
|
int32_t top = marqueeWidget.top + windowPos.y;
|
|
int32_t marqHeight = marqueeWidget.height();
|
|
DrawPixelInfo dpiMarquee;
|
|
if (!ClipDrawPixelInfo(&dpiMarquee, &dpi, { left, top }, marqWidth, marqHeight))
|
|
{
|
|
return;
|
|
}
|
|
|
|
int32_t i = 0;
|
|
for (; i < PEEP_MAX_THOUGHTS; ++i)
|
|
{
|
|
if (peep->Thoughts[i].type == PeepThoughtType::None)
|
|
{
|
|
_marqueePosition = 0;
|
|
return;
|
|
}
|
|
if (peep->Thoughts[i].freshness == 1)
|
|
{ // If a fresh thought
|
|
break;
|
|
}
|
|
}
|
|
if (i == PEEP_MAX_THOUGHTS)
|
|
{
|
|
_marqueePosition = 0;
|
|
return;
|
|
}
|
|
|
|
screenPos.x = marqueeWidget.width() - _marqueePosition;
|
|
{
|
|
auto ft = Formatter();
|
|
PeepThoughtSetFormatArgs(&peep->Thoughts[i], ft);
|
|
DrawTextBasic(dpiMarquee, { screenPos.x, 0 }, STR_WINDOW_COLOUR_2_STRINGID, ft, { FontStyle::Small });
|
|
}
|
|
}
|
|
|
|
void OnPrepareDrawOverview()
|
|
{
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
pressed_widgets &= ~(1uLL << WIDX_TRACK);
|
|
if (peep->PeepFlags & PEEP_FLAGS_TRACKING)
|
|
{
|
|
pressed_widgets |= (1uLL << WIDX_TRACK);
|
|
}
|
|
|
|
widgets[WIDX_VIEWPORT].right = width - 26;
|
|
widgets[WIDX_VIEWPORT].bottom = height - 14;
|
|
|
|
widgets[WIDX_ACTION_LBL].top = height - 12;
|
|
widgets[WIDX_ACTION_LBL].bottom = height - 3;
|
|
widgets[WIDX_ACTION_LBL].right = width - 24;
|
|
|
|
widgets[WIDX_MARQUEE].right = width - 24;
|
|
|
|
widgets[WIDX_PICKUP].right = width - 2;
|
|
widgets[WIDX_RENAME].right = width - 2;
|
|
widgets[WIDX_LOCATE].right = width - 2;
|
|
widgets[WIDX_TRACK].right = width - 2;
|
|
|
|
widgets[WIDX_PICKUP].left = width - 25;
|
|
widgets[WIDX_RENAME].left = width - 25;
|
|
widgets[WIDX_LOCATE].left = width - 25;
|
|
widgets[WIDX_TRACK].left = width - 25;
|
|
}
|
|
|
|
void OnUpdateOverview()
|
|
{
|
|
int32_t newAnimationFrame = _guestAnimationFrame;
|
|
newAnimationFrame++;
|
|
newAnimationFrame %= 24;
|
|
_guestAnimationFrame = newAnimationFrame;
|
|
|
|
WidgetInvalidate(*this, WIDX_TAB_1);
|
|
WidgetInvalidate(*this, WIDX_TAB_2);
|
|
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
if (peep->WindowInvalidateFlags & PEEP_INVALIDATE_PEEP_ACTION)
|
|
{
|
|
peep->WindowInvalidateFlags &= ~PEEP_INVALIDATE_PEEP_ACTION;
|
|
WidgetInvalidate(*this, WIDX_ACTION_LBL);
|
|
}
|
|
|
|
_marqueePosition += 2;
|
|
|
|
_beingWatchedTimer++;
|
|
|
|
// Disable peep watching thought for multiplayer as it's client specific
|
|
if (NetworkGetMode() == NETWORK_MODE_NONE)
|
|
{
|
|
// Create the "I have the strangest feeling I am being watched thought"
|
|
if (_beingWatchedTimer >= 3840)
|
|
{
|
|
if (!(_beingWatchedTimer & 0x3FF))
|
|
{
|
|
int32_t random = UtilRand() & 0xFFFF;
|
|
if (random <= 0x2AAA)
|
|
{
|
|
peep->InsertNewThought(PeepThoughtType::Watched);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnTextInputOverview(WidgetIndex widgetIndex, std::string_view text)
|
|
{
|
|
if (widgetIndex != WIDX_RENAME)
|
|
return;
|
|
|
|
if (text.empty())
|
|
return;
|
|
std::string sText(text);
|
|
auto gameAction = GuestSetNameAction(EntityId::FromUnderlying(number), sText);
|
|
GameActions::Execute(&gameAction);
|
|
}
|
|
|
|
void OnToolUpdateOverview(WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords)
|
|
{
|
|
if (widgetIndex != WIDX_PICKUP)
|
|
return;
|
|
|
|
MapInvalidateSelectionRect();
|
|
|
|
gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE;
|
|
|
|
auto mapCoords = FootpathGetCoordinatesFromPos({ screenCoords.x, screenCoords.y + 16 }, nullptr, nullptr);
|
|
if (!mapCoords.IsNull())
|
|
{
|
|
gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE;
|
|
gMapSelectType = MAP_SELECT_TYPE_FULL;
|
|
gMapSelectPositionA = mapCoords;
|
|
gMapSelectPositionB = mapCoords;
|
|
MapInvalidateSelectionRect();
|
|
}
|
|
|
|
gPickupPeepImage = ImageId();
|
|
|
|
auto info = GetMapCoordinatesFromPos(screenCoords, ViewportInteractionItemAll);
|
|
if (info.SpriteType == ViewportInteractionItem::None)
|
|
return;
|
|
|
|
gPickupPeepX = screenCoords.x - 1;
|
|
gPickupPeepY = screenCoords.y + 16;
|
|
picked_peep_frame++;
|
|
if (picked_peep_frame >= 48)
|
|
{
|
|
picked_peep_frame = 0;
|
|
}
|
|
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
auto baseImageId = GetPeepAnimation(peep->SpriteType, PeepActionSpriteType::Ui).base_image;
|
|
baseImageId += picked_peep_frame >> 2;
|
|
gPickupPeepImage = ImageId(baseImageId, peep->TshirtColour, peep->TrousersColour);
|
|
}
|
|
|
|
void OnToolDownOverview(WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords)
|
|
{
|
|
if (widgetIndex != WIDX_PICKUP)
|
|
return;
|
|
|
|
TileElement* tileElement;
|
|
auto destCoords = FootpathGetCoordinatesFromPos({ screenCoords.x, screenCoords.y + 16 }, nullptr, &tileElement);
|
|
|
|
if (destCoords.IsNull())
|
|
return;
|
|
|
|
PeepPickupAction pickupAction{ PeepPickupType::Place,
|
|
EntityId::FromUnderlying(number),
|
|
{ destCoords, tileElement->GetBaseZ() },
|
|
NetworkGetCurrentPlayerId() };
|
|
pickupAction.SetCallback([](const GameAction* ga, const GameActions::Result* result) {
|
|
if (result->Error != GameActions::Status::Ok)
|
|
return;
|
|
ToolCancel();
|
|
gPickupPeepImage = ImageId();
|
|
});
|
|
GameActions::Execute(&pickupAction);
|
|
}
|
|
|
|
void OnToolAbortOverview(WidgetIndex widgetIndex)
|
|
{
|
|
if (widgetIndex != WIDX_PICKUP)
|
|
return;
|
|
|
|
PeepPickupAction pickupAction{
|
|
PeepPickupType::Cancel, EntityId::FromUnderlying(number), { _pickedPeepX, 0, 0 }, NetworkGetCurrentPlayerId()
|
|
};
|
|
GameActions::Execute(&pickupAction);
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Stats
|
|
void StatsTabDraw(DrawPixelInfo& dpi)
|
|
{
|
|
if (WidgetIsDisabled(*this, WIDX_TAB_2))
|
|
return;
|
|
|
|
const auto& widget = widgets[WIDX_TAB_2];
|
|
auto screenCoords = windowPos + ScreenCoordsXY{ widget.left, widget.top };
|
|
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
int32_t imageId = GetPeepFaceSpriteLarge(peep);
|
|
if (page == WINDOW_GUEST_STATS)
|
|
{
|
|
// If currently viewing this tab animate tab
|
|
// if it is very sick or angry.
|
|
switch (imageId)
|
|
{
|
|
case SPR_PEEP_LARGE_FACE_VERY_VERY_SICK_0:
|
|
imageId += (frame_no / 4) & 0xF;
|
|
break;
|
|
case SPR_PEEP_LARGE_FACE_VERY_SICK_0:
|
|
imageId += (frame_no / 8) & 0x3;
|
|
break;
|
|
case SPR_PEEP_LARGE_FACE_ANGRY_0:
|
|
imageId += (frame_no / 8) & 0x3;
|
|
break;
|
|
}
|
|
}
|
|
GfxDrawSprite(&dpi, ImageId(imageId), screenCoords);
|
|
}
|
|
|
|
void OnUpdateStats()
|
|
{
|
|
frame_no++;
|
|
auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
peep->WindowInvalidateFlags &= ~PEEP_INVALIDATE_PEEP_STATS;
|
|
|
|
Invalidate();
|
|
}
|
|
|
|
void StatsBarsDraw(int32_t value, const ScreenCoordsXY& origCoords, DrawPixelInfo& dpi, int32_t colour, bool blinkFlag)
|
|
{
|
|
auto coords = origCoords;
|
|
if (FontGetLineHeight(FontStyle::Medium) > 10)
|
|
{
|
|
coords.y += 1;
|
|
}
|
|
|
|
GfxFillRectInset(
|
|
&dpi, { coords + ScreenCoordsXY{ 61, 1 }, coords + ScreenCoordsXY{ 61 + 121, 9 } }, colours[1], INSET_RECT_F_30);
|
|
|
|
if (!blinkFlag || GameIsPaused() || (gCurrentRealTimeTicks & 8) == 0)
|
|
{
|
|
value *= 118;
|
|
value >>= 8;
|
|
|
|
if (value <= 2)
|
|
return;
|
|
|
|
GfxFillRectInset(
|
|
&dpi, { coords + ScreenCoordsXY{ 63, 2 }, coords + ScreenCoordsXY{ 63 + value - 1, 8 } }, colour, 0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Takes a guest stat value (scaled to currMax) and adjusts it to be scaled out of 255.
|
|
* Then clamp the value to between newMin and 255.
|
|
*/
|
|
int32_t NormalizeGuestStatValue(int32_t value, int32_t currMax, int32_t newMin) const
|
|
{
|
|
int32_t newValue = (value * 255) / currMax;
|
|
return std::clamp(newValue, newMin, 255);
|
|
}
|
|
|
|
void OnDrawStats(DrawPixelInfo& dpi)
|
|
{
|
|
DrawWidgets(dpi);
|
|
OverviewTabDraw(dpi);
|
|
StatsTabDraw(dpi);
|
|
RidesTabDraw(dpi);
|
|
FinanceTabDraw(dpi);
|
|
ThoughtsTabDraw(dpi);
|
|
InventoryTabDraw(dpi);
|
|
DebugTabDraw(dpi);
|
|
|
|
// ebx
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Not sure why this is not stats widgets
|
|
// cx dx
|
|
auto screenCoords = windowPos
|
|
+ ScreenCoordsXY{ widgets[WIDX_PAGE_BACKGROUND].left + 4, widgets[WIDX_PAGE_BACKGROUND].top + 4 };
|
|
|
|
// Happiness
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_HAPPINESS_LABEL);
|
|
|
|
int32_t happiness = NormalizeGuestStatValue(peep->Happiness, PEEP_MAX_HAPPINESS, 10);
|
|
int32_t barColour = COLOUR_BRIGHT_GREEN;
|
|
bool barBlink = happiness < 50;
|
|
StatsBarsDraw(happiness, screenCoords, dpi, barColour, barBlink);
|
|
|
|
// Energy
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_ENERGY_LABEL);
|
|
|
|
int32_t energy = NormalizeGuestStatValue(peep->Energy - PEEP_MIN_ENERGY, PEEP_MAX_ENERGY - PEEP_MIN_ENERGY, 10);
|
|
barColour = COLOUR_BRIGHT_GREEN;
|
|
barBlink = energy < 50;
|
|
StatsBarsDraw(energy, screenCoords, dpi, barColour, barBlink);
|
|
|
|
// Hunger
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_HUNGER_LABEL);
|
|
|
|
int32_t hunger = NormalizeGuestStatValue(peep->Hunger - 32, 158, 0);
|
|
hunger = 255 - hunger; // the bar should be longer when peep->Hunger is low
|
|
barColour = COLOUR_BRIGHT_RED;
|
|
barBlink = hunger > 170;
|
|
StatsBarsDraw(hunger, screenCoords, dpi, barColour, barBlink);
|
|
|
|
// Thirst
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_THIRST_LABEL);
|
|
|
|
int32_t thirst = NormalizeGuestStatValue(peep->Thirst - 32, 158, 0);
|
|
thirst = 255 - thirst; // the bar should be longer when peep->Thirst is low
|
|
barColour = COLOUR_BRIGHT_RED;
|
|
barBlink = thirst > 170;
|
|
StatsBarsDraw(thirst, screenCoords, dpi, barColour, barBlink);
|
|
|
|
// Nausea
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_NAUSEA_LABEL);
|
|
|
|
int32_t nausea = NormalizeGuestStatValue(peep->Nausea - 32, 223, 0);
|
|
barColour = COLOUR_BRIGHT_RED;
|
|
barBlink = nausea > 120;
|
|
StatsBarsDraw(nausea, screenCoords, dpi, barColour, barBlink);
|
|
|
|
// Toilet
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_TOILET_LABEL);
|
|
|
|
int32_t toilet = NormalizeGuestStatValue(peep->Toilet - 64, 178, 0);
|
|
barColour = COLOUR_BRIGHT_RED;
|
|
barBlink = toilet > 160;
|
|
StatsBarsDraw(toilet, screenCoords, dpi, barColour, barBlink);
|
|
|
|
// Time in park
|
|
screenCoords.y += LIST_ROW_HEIGHT + 1;
|
|
int32_t guestEntryTime = peep->GetParkEntryTime();
|
|
if (guestEntryTime != -1)
|
|
{
|
|
int32_t timeInPark = (gCurrentTicks - guestEntryTime) >> 11;
|
|
auto ft = Formatter();
|
|
ft.Add<uint16_t>(timeInPark & 0xFFFF);
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_TIME_IN_PARK, ft);
|
|
}
|
|
|
|
screenCoords.y += LIST_ROW_HEIGHT + 9;
|
|
GfxFillRectInset(
|
|
&dpi, { screenCoords - ScreenCoordsXY{ 0, 6 }, screenCoords + ScreenCoordsXY{ 179, -5 } }, colours[1],
|
|
INSET_RECT_FLAG_BORDER_INSET);
|
|
|
|
// Preferred Ride
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_PREFERRED_RIDE);
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
|
|
// Intensity
|
|
{
|
|
auto ft = Formatter();
|
|
auto maxIntensity = peep->Intensity.GetMaximum();
|
|
int32_t string_id = STR_GUEST_STAT_PREFERRED_INTESITY_BELOW;
|
|
if (peep->Intensity.GetMinimum() != 0)
|
|
{
|
|
ft.Add<uint16_t>(peep->Intensity.GetMinimum());
|
|
ft.Add<uint16_t>(maxIntensity);
|
|
string_id = STR_GUEST_STAT_PREFERRED_INTESITY_BETWEEN;
|
|
if (maxIntensity == 15)
|
|
string_id = STR_GUEST_STAT_PREFERRED_INTESITY_ABOVE;
|
|
}
|
|
else
|
|
{
|
|
ft.Add<uint16_t>(maxIntensity);
|
|
}
|
|
|
|
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 4, 0 }, string_id, ft);
|
|
}
|
|
|
|
// Nausea tolerance
|
|
{
|
|
static constexpr const StringId _nauseaTolerances[] = {
|
|
STR_PEEP_STAT_NAUSEA_TOLERANCE_NONE,
|
|
STR_PEEP_STAT_NAUSEA_TOLERANCE_LOW,
|
|
STR_PEEP_STAT_NAUSEA_TOLERANCE_AVERAGE,
|
|
STR_PEEP_STAT_NAUSEA_TOLERANCE_HIGH,
|
|
};
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
auto nausea_tolerance = EnumValue(peep->NauseaTolerance) & 0x3;
|
|
auto ft = Formatter();
|
|
ft.Add<StringId>(_nauseaTolerances[nausea_tolerance]);
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_NAUSEA_TOLERANCE, ft);
|
|
}
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Rides
|
|
void RidesTabDraw(DrawPixelInfo& dpi)
|
|
{
|
|
if (WidgetIsDisabled(*this, WIDX_TAB_3))
|
|
return;
|
|
|
|
const auto& widget = widgets[WIDX_TAB_3];
|
|
auto screenCoords = windowPos + ScreenCoordsXY{ widget.left, widget.top };
|
|
|
|
int32_t imageId = SPR_TAB_RIDE_0;
|
|
|
|
if (page == WINDOW_GUEST_RIDES)
|
|
{
|
|
imageId += (frame_no / 4) & 0xF;
|
|
}
|
|
|
|
GfxDrawSprite(&dpi, ImageId(imageId), screenCoords);
|
|
}
|
|
|
|
void OnUpdateRides()
|
|
{
|
|
frame_no++;
|
|
|
|
WidgetInvalidate(*this, WIDX_TAB_2);
|
|
WidgetInvalidate(*this, WIDX_TAB_3);
|
|
|
|
const auto guest = GetGuest();
|
|
if (guest == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Every 2048 ticks do a full window_invalidate
|
|
int32_t numTicks = gCurrentTicks - guest->GetParkEntryTime();
|
|
if (!(numTicks & 0x7FF))
|
|
Invalidate();
|
|
|
|
uint8_t currListPosition = 0;
|
|
for (const auto& r : GetRideManager())
|
|
{
|
|
if (r.IsRide() && guest->HasRidden(r))
|
|
{
|
|
list_item_positions[currListPosition] = r.id.ToUnderlying();
|
|
currListPosition++;
|
|
}
|
|
}
|
|
|
|
// If there are new items
|
|
if (no_list_items != currListPosition)
|
|
{
|
|
no_list_items = currListPosition;
|
|
Invalidate();
|
|
}
|
|
}
|
|
|
|
ScreenSize OnScrollGetSizeRides(int32_t scrollIndex)
|
|
{
|
|
ScreenSize newSize;
|
|
newSize.height = no_list_items * 10;
|
|
|
|
if (selected_list_item != -1)
|
|
{
|
|
selected_list_item = -1;
|
|
Invalidate();
|
|
}
|
|
|
|
int32_t visableHeight = newSize.height - widgets[WIDX_RIDE_SCROLL].bottom + widgets[WIDX_RIDE_SCROLL].top + 21;
|
|
|
|
if (visableHeight < 0)
|
|
visableHeight = 0;
|
|
|
|
if (visableHeight < scrolls[0].v_top)
|
|
{
|
|
scrolls[0].v_top = visableHeight;
|
|
Invalidate();
|
|
}
|
|
return newSize;
|
|
}
|
|
|
|
void OnScrollMouseDownRides(int32_t scrollIndex, const ScreenCoordsXY& screenCoords)
|
|
{
|
|
auto index = screenCoords.y / 10;
|
|
if (index >= no_list_items)
|
|
return;
|
|
|
|
auto intent = Intent(WindowClass::Ride);
|
|
intent.PutExtra(INTENT_EXTRA_RIDE_ID, list_item_positions[index]);
|
|
ContextOpenIntent(&intent);
|
|
}
|
|
|
|
void OnScrollMouseOverRides(int32_t scrollIndex, const ScreenCoordsXY& screenCoords)
|
|
{
|
|
auto index = screenCoords.y / 10;
|
|
if (index >= no_list_items)
|
|
return;
|
|
|
|
if (index == selected_list_item)
|
|
return;
|
|
selected_list_item = index;
|
|
|
|
Invalidate();
|
|
}
|
|
|
|
void OnPrepareDrawRides()
|
|
{
|
|
widgets[WIDX_RIDE_SCROLL].right = width - 4;
|
|
widgets[WIDX_RIDE_SCROLL].bottom = height - 15;
|
|
}
|
|
|
|
void OnDrawRides(DrawPixelInfo& dpi)
|
|
{
|
|
DrawWidgets(dpi);
|
|
OverviewTabDraw(dpi);
|
|
StatsTabDraw(dpi);
|
|
RidesTabDraw(dpi);
|
|
FinanceTabDraw(dpi);
|
|
ThoughtsTabDraw(dpi);
|
|
InventoryTabDraw(dpi);
|
|
DebugTabDraw(dpi);
|
|
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// cx dx
|
|
auto screenCoords = windowPos
|
|
+ ScreenCoordsXY{ widgets[WIDX_PAGE_BACKGROUND].left + 2, widgets[WIDX_PAGE_BACKGROUND].top + 2 };
|
|
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_LABEL_RIDES_BEEN_ON);
|
|
|
|
screenCoords.y = windowPos.y + widgets[WIDX_PAGE_BACKGROUND].bottom - 12;
|
|
|
|
auto ft = Formatter();
|
|
auto* r = GetRide(peep->FavouriteRide);
|
|
if (r != nullptr)
|
|
{
|
|
r->FormatNameTo(ft);
|
|
}
|
|
else
|
|
{
|
|
ft.Add<StringId>(STR_PEEP_FAVOURITE_RIDE_NOT_AVAILABLE);
|
|
}
|
|
|
|
DrawTextEllipsised(dpi, screenCoords, width - 14, STR_FAVOURITE_RIDE, ft);
|
|
}
|
|
|
|
void OnScrollDrawRides(int32_t scrollIndex, DrawPixelInfo& dpi)
|
|
{
|
|
auto colour = ColourMapA[colours[1]].mid_light;
|
|
GfxFillRect(&dpi, { { dpi.x, dpi.y }, { dpi.x + dpi.width - 1, dpi.y + dpi.height - 1 } }, colour);
|
|
|
|
for (int32_t listIndex = 0; listIndex < no_list_items; listIndex++)
|
|
{
|
|
auto y = listIndex * 10;
|
|
StringId stringId = STR_BLACK_STRING;
|
|
if (listIndex == selected_list_item)
|
|
{
|
|
GfxFilterRect(&dpi, { 0, y, 800, y + 9 }, FilterPaletteID::PaletteDarken1);
|
|
stringId = STR_WINDOW_COLOUR_2_STRINGID;
|
|
}
|
|
|
|
const auto rId = RideId::FromUnderlying(list_item_positions[listIndex]);
|
|
auto* r = GetRide(rId);
|
|
if (r != nullptr)
|
|
{
|
|
auto ft = Formatter();
|
|
r->FormatNameTo(ft);
|
|
DrawTextBasic(dpi, { 0, y - 1 }, stringId, ft);
|
|
}
|
|
}
|
|
}
|
|
#pragma endregion
|
|
|
|
#pragma region Finance
|
|
void FinanceTabDraw(DrawPixelInfo& dpi)
|
|
{
|
|
if (WidgetIsDisabled(*this, WIDX_TAB_4))
|
|
return;
|
|
|
|
const auto& widget = widgets[WIDX_TAB_4];
|
|
auto screenCoords = windowPos + ScreenCoordsXY{ widget.left, widget.top };
|
|
|
|
int32_t imageId = SPR_TAB_FINANCES_SUMMARY_0;
|
|
|
|
if (page == WINDOW_GUEST_FINANCE)
|
|
{
|
|
imageId += (frame_no / 2) & 0x7;
|
|
}
|
|
|
|
GfxDrawSprite(&dpi, ImageId(imageId), screenCoords);
|
|
}
|
|
|
|
void OnUpdateFinance()
|
|
{
|
|
frame_no++;
|
|
|
|
WidgetInvalidate(*this, WIDX_TAB_2);
|
|
WidgetInvalidate(*this, WIDX_TAB_4);
|
|
}
|
|
|
|
void OnDrawFinance(DrawPixelInfo& dpi)
|
|
{
|
|
DrawWidgets(dpi);
|
|
OverviewTabDraw(dpi);
|
|
StatsTabDraw(dpi);
|
|
RidesTabDraw(dpi);
|
|
FinanceTabDraw(dpi);
|
|
ThoughtsTabDraw(dpi);
|
|
InventoryTabDraw(dpi);
|
|
DebugTabDraw(dpi);
|
|
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// cx dx
|
|
auto screenCoords = windowPos
|
|
+ ScreenCoordsXY{ widgets[WIDX_PAGE_BACKGROUND].left + 4, widgets[WIDX_PAGE_BACKGROUND].top + 4 };
|
|
|
|
// Cash in pocket
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<money64>(peep->CashInPocket);
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_CASH_IN_POCKET, ft);
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
}
|
|
|
|
// Cash spent
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<money64>(peep->CashSpent);
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_CASH_SPENT, ft);
|
|
screenCoords.y += LIST_ROW_HEIGHT * 2;
|
|
}
|
|
|
|
GfxFillRectInset(
|
|
&dpi, { screenCoords - ScreenCoordsXY{ 0, 6 }, screenCoords + ScreenCoordsXY{ 179, -5 } }, colours[1],
|
|
INSET_RECT_FLAG_BORDER_INSET);
|
|
|
|
// Paid to enter
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<money64>(peep->PaidToEnter);
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_ENTRANCE_FEE, ft);
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
}
|
|
// Paid on rides
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<money64>(peep->PaidOnRides);
|
|
ft.Add<uint16_t>(peep->GuestNumRides);
|
|
if (peep->GuestNumRides != 1)
|
|
{
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_RIDE_PLURAL, ft);
|
|
}
|
|
else
|
|
{
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_RIDE, ft);
|
|
}
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
}
|
|
// Paid on food
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<money64>(peep->PaidOnFood);
|
|
ft.Add<uint16_t>(peep->AmountOfFood);
|
|
if (peep->AmountOfFood != 1)
|
|
{
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_FOOD_PLURAL, ft);
|
|
}
|
|
else
|
|
{
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_FOOD, ft);
|
|
}
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
}
|
|
|
|
// Paid on drinks
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<money64>(peep->PaidOnDrink);
|
|
ft.Add<uint16_t>(peep->AmountOfDrinks);
|
|
if (peep->AmountOfDrinks != 1)
|
|
{
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_DRINK_PLURAL, ft);
|
|
}
|
|
else
|
|
{
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_DRINK, ft);
|
|
}
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
}
|
|
// Paid on souvenirs
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<money64>(peep->PaidOnSouvenirs);
|
|
ft.Add<uint16_t>(peep->AmountOfSouvenirs);
|
|
if (peep->AmountOfSouvenirs != 1)
|
|
{
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_SOUVENIR_PLURAL, ft);
|
|
}
|
|
else
|
|
{
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_SOUVENIR, ft);
|
|
}
|
|
}
|
|
}
|
|
#pragma endregion
|
|
|
|
#pragma region Thoughts
|
|
void ThoughtsTabDraw(DrawPixelInfo& dpi)
|
|
{
|
|
if (WidgetIsDisabled(*this, WIDX_TAB_5))
|
|
return;
|
|
|
|
const auto& widget = widgets[WIDX_TAB_5];
|
|
auto screenCoords = windowPos + ScreenCoordsXY{ widget.left, widget.top };
|
|
|
|
int32_t imageId = SPR_TAB_THOUGHTS_0;
|
|
|
|
if (page == WINDOW_GUEST_THOUGHTS)
|
|
{
|
|
imageId += (frame_no / 2) & 0x7;
|
|
}
|
|
|
|
GfxDrawSprite(&dpi, ImageId(imageId), screenCoords);
|
|
}
|
|
|
|
void OnUpdateThoughts()
|
|
{
|
|
frame_no++;
|
|
|
|
WidgetInvalidate(*this, WIDX_TAB_2);
|
|
WidgetInvalidate(*this, WIDX_TAB_5);
|
|
|
|
auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
if (peep->WindowInvalidateFlags & PEEP_INVALIDATE_PEEP_THOUGHTS)
|
|
{
|
|
peep->WindowInvalidateFlags &= ~PEEP_INVALIDATE_PEEP_THOUGHTS;
|
|
Invalidate();
|
|
}
|
|
}
|
|
|
|
void OnDrawThoughts(DrawPixelInfo& dpi)
|
|
{
|
|
DrawWidgets(dpi);
|
|
OverviewTabDraw(dpi);
|
|
StatsTabDraw(dpi);
|
|
RidesTabDraw(dpi);
|
|
FinanceTabDraw(dpi);
|
|
ThoughtsTabDraw(dpi);
|
|
InventoryTabDraw(dpi);
|
|
DebugTabDraw(dpi);
|
|
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// cx dx
|
|
auto screenCoords = windowPos
|
|
+ ScreenCoordsXY{ widgets[WIDX_PAGE_BACKGROUND].left + 4, widgets[WIDX_PAGE_BACKGROUND].top + 4 };
|
|
|
|
DrawTextBasic(dpi, screenCoords, STR_GUEST_RECENT_THOUGHTS_LABEL);
|
|
|
|
screenCoords.y += 10;
|
|
for (const auto& thought : peep->Thoughts)
|
|
{
|
|
if (thought.type == PeepThoughtType::None)
|
|
return;
|
|
if (thought.freshness == 0)
|
|
continue;
|
|
|
|
int32_t widgWidth = widgets[WIDX_PAGE_BACKGROUND].right - widgets[WIDX_PAGE_BACKGROUND].left - 8;
|
|
|
|
auto ft = Formatter();
|
|
PeepThoughtSetFormatArgs(&thought, ft);
|
|
screenCoords.y += DrawTextWrapped(dpi, screenCoords, widgWidth, STR_BLACK_STRING, ft, { FontStyle::Small });
|
|
|
|
// If this is the last visible line end drawing.
|
|
if (screenCoords.y > windowPos.y + widgets[WIDX_PAGE_BACKGROUND].bottom - 32)
|
|
return;
|
|
}
|
|
}
|
|
#pragma endregion
|
|
|
|
#pragma region Inventory
|
|
void InventoryTabDraw(DrawPixelInfo& dpi)
|
|
{
|
|
if (WidgetIsDisabled(*this, WIDX_TAB_6))
|
|
return;
|
|
|
|
const auto& widget = widgets[WIDX_TAB_6];
|
|
auto screenCoords = windowPos + ScreenCoordsXY{ widget.left, widget.top };
|
|
|
|
GfxDrawSprite(&dpi, ImageId(SPR_TAB_GUEST_INVENTORY), screenCoords);
|
|
}
|
|
|
|
void OnUpdateInventory()
|
|
{
|
|
frame_no++;
|
|
|
|
WidgetInvalidate(*this, WIDX_TAB_2);
|
|
WidgetInvalidate(*this, WIDX_TAB_6);
|
|
|
|
auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
if (peep->WindowInvalidateFlags & PEEP_INVALIDATE_PEEP_INVENTORY)
|
|
{
|
|
peep->WindowInvalidateFlags &= ~PEEP_INVALIDATE_PEEP_INVENTORY;
|
|
Invalidate();
|
|
}
|
|
}
|
|
|
|
std::pair<StringId, Formatter> InventoryFormatItem(Guest& guest, ShopItem item) const
|
|
{
|
|
auto& park = OpenRCT2::GetContext()->GetGameState()->GetPark();
|
|
auto parkName = park.Name.c_str();
|
|
|
|
// Default arguments
|
|
auto ft = Formatter();
|
|
ft.Add<uint32_t>(GetShopItemDescriptor(item).Image);
|
|
ft.Add<StringId>(GetShopItemDescriptor(item).Naming.Display);
|
|
ft.Add<StringId>(STR_STRING);
|
|
ft.Add<const char*>(parkName);
|
|
|
|
// Special overrides
|
|
Ride* invRide{};
|
|
switch (item)
|
|
{
|
|
case ShopItem::Balloon:
|
|
ft.Rewind();
|
|
ft.Add<uint32_t>(ImageId(GetShopItemDescriptor(item).Image, (guest.BalloonColour)).ToUInt32());
|
|
break;
|
|
case ShopItem::Photo:
|
|
invRide = GetRide(guest.Photo1RideRef);
|
|
if (invRide != nullptr)
|
|
{
|
|
ft.Rewind();
|
|
ft.Increment(6);
|
|
invRide->FormatNameTo(ft);
|
|
}
|
|
|
|
break;
|
|
case ShopItem::Umbrella:
|
|
ft.Rewind();
|
|
ft.Add<uint32_t>(ImageId(GetShopItemDescriptor(item).Image, (guest.UmbrellaColour)).ToUInt32());
|
|
break;
|
|
case ShopItem::Voucher:
|
|
switch (guest.VoucherType)
|
|
{
|
|
case VOUCHER_TYPE_PARK_ENTRY_FREE:
|
|
ft.Rewind();
|
|
ft.Increment(6);
|
|
ft.Add<StringId>(STR_PEEP_INVENTORY_VOUCHER_PARK_ENTRY_FREE);
|
|
ft.Add<StringId>(STR_STRING);
|
|
ft.Add<const char*>(parkName);
|
|
break;
|
|
case VOUCHER_TYPE_RIDE_FREE:
|
|
invRide = GetRide(guest.VoucherRideId);
|
|
if (invRide != nullptr)
|
|
{
|
|
ft.Rewind();
|
|
ft.Increment(6);
|
|
ft.Add<StringId>(STR_PEEP_INVENTORY_VOUCHER_RIDE_FREE);
|
|
invRide->FormatNameTo(ft);
|
|
}
|
|
break;
|
|
case VOUCHER_TYPE_PARK_ENTRY_HALF_PRICE:
|
|
ft.Rewind();
|
|
ft.Increment(6);
|
|
ft.Add<StringId>(STR_PEEP_INVENTORY_VOUCHER_PARK_ENTRY_HALF_PRICE);
|
|
ft.Add<StringId>(STR_STRING);
|
|
ft.Add<const char*>(parkName);
|
|
break;
|
|
case VOUCHER_TYPE_FOOD_OR_DRINK_FREE:
|
|
ft.Rewind();
|
|
ft.Increment(6);
|
|
ft.Add<StringId>(STR_PEEP_INVENTORY_VOUCHER_FOOD_OR_DRINK_FREE);
|
|
ft.Add<StringId>(GetShopItemDescriptor(guest.VoucherShopItem).Naming.Singular);
|
|
break;
|
|
}
|
|
break;
|
|
case ShopItem::Hat:
|
|
ft.Rewind();
|
|
ft.Add<uint32_t>(ImageId(GetShopItemDescriptor(item).Image, (guest.HatColour)).ToUInt32());
|
|
break;
|
|
case ShopItem::TShirt:
|
|
ft.Rewind();
|
|
ft.Add<uint32_t>(ImageId(GetShopItemDescriptor(item).Image, (guest.TshirtColour)).ToUInt32());
|
|
break;
|
|
case ShopItem::Photo2:
|
|
invRide = GetRide(guest.Photo2RideRef);
|
|
if (invRide != nullptr)
|
|
{
|
|
ft.Rewind();
|
|
ft.Increment(6);
|
|
invRide->FormatNameTo(ft);
|
|
}
|
|
break;
|
|
case ShopItem::Photo3:
|
|
invRide = GetRide(guest.Photo3RideRef);
|
|
if (invRide != nullptr)
|
|
{
|
|
ft.Rewind();
|
|
ft.Increment(6);
|
|
invRide->FormatNameTo(ft);
|
|
}
|
|
break;
|
|
case ShopItem::Photo4:
|
|
invRide = GetRide(guest.Photo4RideRef);
|
|
if (invRide != nullptr)
|
|
{
|
|
ft.Rewind();
|
|
ft.Increment(6);
|
|
invRide->FormatNameTo(ft);
|
|
}
|
|
break;
|
|
default:
|
|
// This switch handles only items visible in peep window
|
|
break;
|
|
}
|
|
|
|
return std::make_pair(STR_GUEST_ITEM_FORMAT, ft);
|
|
}
|
|
|
|
void OnDrawInventory(DrawPixelInfo& dpi)
|
|
{
|
|
DrawWidgets(dpi);
|
|
OverviewTabDraw(dpi);
|
|
StatsTabDraw(dpi);
|
|
RidesTabDraw(dpi);
|
|
FinanceTabDraw(dpi);
|
|
ThoughtsTabDraw(dpi);
|
|
InventoryTabDraw(dpi);
|
|
DebugTabDraw(dpi);
|
|
|
|
const auto guest = GetGuest();
|
|
if (guest == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Widget* pageBackgroundWidget = &widgets[WIDX_PAGE_BACKGROUND];
|
|
auto screenCoords = windowPos + ScreenCoordsXY{ pageBackgroundWidget->left + 4, pageBackgroundWidget->top + 2 };
|
|
int32_t itemNameWidth = pageBackgroundWidget->width() - 8;
|
|
|
|
int32_t maxY = windowPos.y + height - 22;
|
|
int32_t numItems = 0;
|
|
|
|
DrawTextBasic(dpi, screenCoords, STR_CARRYING);
|
|
screenCoords.y += 10;
|
|
|
|
for (ShopItem item = ShopItem::Balloon; item < ShopItem::Count; item++)
|
|
{
|
|
if (screenCoords.y >= maxY)
|
|
break;
|
|
if (!guest->HasItem(item))
|
|
continue;
|
|
|
|
auto [stringId, ft] = InventoryFormatItem(*guest, item);
|
|
screenCoords.y += DrawTextWrapped(dpi, screenCoords, itemNameWidth, stringId, ft);
|
|
numItems++;
|
|
}
|
|
|
|
if (numItems == 0)
|
|
{
|
|
DrawTextBasic(dpi, screenCoords, STR_NOTHING);
|
|
}
|
|
}
|
|
#pragma endregion
|
|
|
|
#pragma region Debug
|
|
void DebugTabDraw(DrawPixelInfo& dpi)
|
|
{
|
|
if (WidgetIsDisabled(*this, WIDX_TAB_7))
|
|
return;
|
|
|
|
const auto& widget = widgets[WIDX_TAB_7];
|
|
auto screenCoords = windowPos + ScreenCoordsXY{ widget.left, widget.top };
|
|
|
|
int32_t imageId = SPR_TAB_GEARS_0;
|
|
if (page == WINDOW_GUEST_DEBUG)
|
|
{
|
|
imageId += (frame_no / 2) & 0x3;
|
|
}
|
|
|
|
GfxDrawSprite(&dpi, ImageId(imageId), screenCoords);
|
|
}
|
|
|
|
void OnUpdateDebug()
|
|
{
|
|
frame_no++;
|
|
Invalidate();
|
|
}
|
|
|
|
void OnDrawDebug(DrawPixelInfo& dpi)
|
|
{
|
|
char buffer[512]{};
|
|
char buffer2[512]{};
|
|
|
|
DrawWidgets(dpi);
|
|
OverviewTabDraw(dpi);
|
|
StatsTabDraw(dpi);
|
|
RidesTabDraw(dpi);
|
|
FinanceTabDraw(dpi);
|
|
ThoughtsTabDraw(dpi);
|
|
InventoryTabDraw(dpi);
|
|
DebugTabDraw(dpi);
|
|
|
|
const auto peep = GetGuest();
|
|
if (peep == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
auto screenCoords = windowPos
|
|
+ ScreenCoordsXY{ widgets[WIDX_PAGE_BACKGROUND].left + 4, widgets[WIDX_PAGE_BACKGROUND].top + 4 };
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<uint32_t>(peep->Id);
|
|
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_SPRITE_INDEX, ft);
|
|
}
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<int32_t>(peep->x);
|
|
ft.Add<int32_t>(peep->y);
|
|
ft.Add<int32_t>(peep->z);
|
|
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_POSITION, ft);
|
|
}
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<int32_t>(peep->NextLoc.x);
|
|
ft.Add<int32_t>(peep->NextLoc.y);
|
|
ft.Add<int32_t>(peep->NextLoc.z);
|
|
OpenRCT2::FormatStringLegacy(buffer, sizeof(buffer), STR_PEEP_DEBUG_NEXT, ft.Data());
|
|
if (peep->GetNextIsSurface())
|
|
{
|
|
OpenRCT2::FormatStringLegacy(buffer2, sizeof(buffer2), STR_PEEP_DEBUG_NEXT_SURFACE, nullptr);
|
|
SafeStrCat(buffer, buffer2, sizeof(buffer));
|
|
}
|
|
if (peep->GetNextIsSloped())
|
|
{
|
|
auto ft2 = Formatter();
|
|
ft2.Add<int32_t>(peep->GetNextDirection());
|
|
OpenRCT2::FormatStringLegacy(buffer2, sizeof(buffer2), STR_PEEP_DEBUG_NEXT_SLOPE, ft2.Data());
|
|
SafeStrCat(buffer, buffer2, sizeof(buffer));
|
|
}
|
|
GfxDrawString(dpi, screenCoords, buffer, {});
|
|
}
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<int32_t>(peep->DestinationX);
|
|
ft.Add<int32_t>(peep->DestinationY);
|
|
ft.Add<int32_t>(peep->DestinationTolerance);
|
|
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_DEST, ft);
|
|
}
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<int32_t>(peep->PathfindGoal.x);
|
|
ft.Add<int32_t>(peep->PathfindGoal.y);
|
|
ft.Add<int32_t>(peep->PathfindGoal.z);
|
|
ft.Add<int32_t>(peep->PathfindGoal.direction);
|
|
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_PATHFIND_GOAL, ft);
|
|
}
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_PATHFIND_HISTORY);
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
|
|
screenCoords.x += 10;
|
|
for (auto& point : peep->PathfindHistory)
|
|
{
|
|
auto ft = Formatter();
|
|
ft.Add<int32_t>(point.x);
|
|
ft.Add<int32_t>(point.y);
|
|
ft.Add<int32_t>(point.z);
|
|
ft.Add<int32_t>(point.direction);
|
|
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_PATHFIND_HISTORY_ITEM, ft);
|
|
screenCoords.y += LIST_ROW_HEIGHT;
|
|
}
|
|
screenCoords.x -= 10;
|
|
}
|
|
#pragma endregion
|
|
};
|
|
|
|
/**
|
|
*
|
|
* rct2: 0x006989E9
|
|
*
|
|
*/
|
|
WindowBase* WindowGuestOpen(Peep* peep)
|
|
{
|
|
if (peep == nullptr)
|
|
{
|
|
return nullptr;
|
|
}
|
|
if (peep->Is<Staff>())
|
|
{
|
|
return WindowStaffOpen(peep);
|
|
}
|
|
|
|
auto* window = static_cast<GuestWindow*>(WindowBringToFrontByNumber(WindowClass::Peep, peep->Id.ToUnderlying()));
|
|
if (window == nullptr)
|
|
{
|
|
int32_t windowWidth = 192;
|
|
if (gConfigGeneral.DebuggingTools)
|
|
windowWidth += TabWidth;
|
|
|
|
window = WindowCreate<GuestWindow>(WindowClass::Peep, windowWidth, 157, WF_RESIZABLE);
|
|
if (window == nullptr)
|
|
{
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
window->Init(peep->Id);
|
|
|
|
return window;
|
|
}
|