static rct_string_id window_editor_inventions_list_prepare_name(const rct_research_item* researchItem, bool withGap)
{
rct_string_id drawString;
rct_string_id stringId = research_item_get_name(researchItem);
if (researchItem->type == RESEARCH_ENTRY_TYPE_RIDE && !RideGroupManager::RideTypeIsIndependent(researchItem->baseRideType))
{
drawString = withGap ? STR_INVENTIONS_LIST_RIDE_AND_VEHICLE_NAME_DRAG : STR_WINDOW_COLOUR_2_STRINGID_STRINGID;
rct_string_id rideGroupName = get_ride_naming(researchItem->baseRideType, get_ride_entry(researchItem->entryIndex))
.name;
set_format_arg(0, rct_string_id, rideGroupName);
set_format_arg(2, rct_string_id, stringId);
}
else
{
drawString = STR_WINDOW_COLOUR_2_STRINGID;
set_format_arg(0, rct_string_id, stringId);
}
return drawString;
}
/**
*
* rct2: 0x006CF2D6
*/
static void window_track_list_invalidate(rct_window *w)
{
rct_string_id stringId = STR_NONE;
rct_ride_entry *entry = get_ride_entry(_window_track_list_item.entry_index);
if (entry != NULL && entry != (rct_ride_entry*)-1) {
rct_ride_name rideName = get_ride_naming(_window_track_list_item.type, entry);
stringId = rideName.name;
}
set_format_arg(0, rct_string_id, stringId);
if (gScreenFlags & SCREEN_FLAGS_TRACK_MANAGER) {
window_track_list_widgets[WIDX_TITLE].text = STR_TRACK_DESIGNS;
window_track_list_widgets[WIDX_TRACK_LIST].tooltip = STR_CLICK_ON_DESIGN_TO_RENAME_OR_DELETE_IT;
} else {
window_track_list_widgets[WIDX_TITLE].text = STR_SELECT_DESIGN;
window_track_list_widgets[WIDX_TRACK_LIST].tooltip = STR_CLICK_ON_DESIGN_TO_BUILD_IT_TIP;
}
if ((gScreenFlags & SCREEN_FLAGS_TRACK_MANAGER) || w->selected_list_item != 0) {
w->pressed_widgets |= 1 << WIDX_TRACK_PREVIEW;
w->disabled_widgets &= ~(1 << WIDX_TRACK_PREVIEW);
window_track_list_widgets[WIDX_ROTATE].type = WWT_FLATBTN;
window_track_list_widgets[WIDX_TOGGLE_SCENERY].type = WWT_FLATBTN;
if (gTrackDesignSceneryToggle) {
w->pressed_widgets &= ~(1 << WIDX_TOGGLE_SCENERY);
} else {
w->pressed_widgets |= (1 << WIDX_TOGGLE_SCENERY);
}
} else {
w->pressed_widgets &= ~(1 << WIDX_TRACK_PREVIEW);
w->disabled_widgets |= (1 << WIDX_TRACK_PREVIEW);
window_track_list_widgets[WIDX_ROTATE].type = WWT_EMPTY;
window_track_list_widgets[WIDX_TOGGLE_SCENERY].type = WWT_EMPTY;
}
}
/**
*
* rct2: 0x006852F4
*/
static void window_editor_inventions_list_drag_open(rct_research_item* researchItem)
{
char buffer[256], *ptr;
int32_t stringWidth;
rct_window* w;
window_close_by_class(WC_EDITOR_INVENTION_LIST_DRAG);
_editorInventionsListDraggedItem = researchItem;
rct_string_id stringId = research_item_get_name(researchItem);
ptr = buffer;
if (researchItem->type == RESEARCH_ENTRY_TYPE_RIDE && !RideGroupManager::RideTypeIsIndependent(researchItem->baseRideType))
{
const auto rideEntry = get_ride_entry(researchItem->entryIndex);
const rct_string_id rideGroupName = get_ride_naming(researchItem->baseRideType, rideEntry).name;
rct_string_id args[] = {
rideGroupName,
stringId,
};
format_string(ptr, 256, STR_INVENTIONS_LIST_RIDE_AND_VEHICLE_NAME, &args);
}
else
{
format_string(ptr, 256, stringId, nullptr);
}
stringWidth = gfx_get_string_width(buffer);
window_editor_inventions_list_drag_widgets[0].right = stringWidth;
w = window_create(
gTooltipCursorX - (stringWidth / 2), gTooltipCursorY - 7, stringWidth, 14, &window_editor_inventions_list_drag_events,
WC_EDITOR_INVENTION_LIST_DRAG, WF_STICK_TO_FRONT | WF_TRANSPARENT | WF_NO_SNAPPING);
w->widgets = window_editor_inventions_list_drag_widgets;
w->colours[1] = COLOUR_WHITE;
input_window_position_begin(w, 0, gTooltipCursorX, gTooltipCursorY);
}
/**
*
* rct2: 0x006D3B1F
*/
static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
window_draw_widgets(w, dpi);
// Track preview
rct_widget* widget = &window_install_track_widgets[WIDX_TRACK_PREVIEW];
int32_t x = w->x + widget->left + 1;
int32_t y = w->y + widget->top + 1;
int32_t colour = ColourMapA[w->colours[0]].darkest;
gfx_fill_rect(dpi, x, y, x + 369, y + 216, colour);
rct_g1_element g1temp = {};
g1temp.offset = _trackDesignPreviewPixels.data() + (_currentTrackPieceDirection * TRACK_PREVIEW_IMAGE_SIZE);
g1temp.width = 370;
g1temp.height = 217;
g1temp.flags = G1_FLAG_BMP;
gfx_set_g1_element(SPR_TEMP, &g1temp);
gfx_draw_sprite(dpi, SPR_TEMP, x, y, 0);
x = w->x + (widget->left + widget->right) / 2;
y = w->y + widget->bottom - 12;
// Warnings
rct_track_td6* td6 = _trackDesign;
if (td6->track_flags & TRACK_DESIGN_FLAG_SCENERY_UNAVAILABLE)
{
if (!gTrackDesignSceneryToggle)
{
// Scenery not available
gfx_draw_string_centred_clipped(
dpi, STR_DESIGN_INCLUDES_SCENERY_WHICH_IS_UNAVAILABLE, nullptr, COLOUR_BLACK, x, y, 368);
y -= LIST_ROW_HEIGHT;
}
}
// Information
x = w->x + widget->left + 1;
y = w->y + widget->bottom + 4;
// 0x006D3CF1 -- 0x006d3d71 missing
// Track design name & type
auto trackName = _trackName.c_str();
gfx_draw_string_left(dpi, STR_TRACK_DESIGN_NAME, &trackName, COLOUR_BLACK, x - 1, y);
y += LIST_ROW_HEIGHT;
rct_ride_name rideName;
rct_string_id friendlyTrackName;
void* objectEntry = object_manager_load_object(&td6->vehicle_object);
if (objectEntry != nullptr)
{
int32_t groupIndex = object_manager_get_loaded_object_entry_index(objectEntry);
rideName = get_ride_naming(td6->type, get_ride_entry(groupIndex));
friendlyTrackName = rideName.name;
}
else
{
// Fall back on the technical track name if the vehicle object cannot be loaded
friendlyTrackName = RideNaming[td6->type].name;
}
gfx_draw_string_left(dpi, STR_TRACK_DESIGN_TYPE, &friendlyTrackName, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT + 4;
// Stats
fixed32_2dp rating = td6->excitement * 10;
gfx_draw_string_left(dpi, STR_TRACK_LIST_EXCITEMENT_RATING, &rating, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
rating = td6->intensity * 10;
gfx_draw_string_left(dpi, STR_TRACK_LIST_INTENSITY_RATING, &rating, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
rating = td6->nausea * 10;
gfx_draw_string_left(dpi, STR_TRACK_LIST_NAUSEA_RATING, &rating, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT + 4;
if (td6->type != RIDE_TYPE_MAZE)
{
if (td6->type == RIDE_TYPE_MINI_GOLF)
{
// Holes
uint16_t holes = td6->holes & 0x1F;
gfx_draw_string_left(dpi, STR_HOLES, &holes, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
}
else
{
// Maximum speed
uint16_t speed = ((td6->max_speed << 16) * 9) >> 18;
gfx_draw_string_left(dpi, STR_MAX_SPEED, &speed, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
// Average speed
speed = ((td6->average_speed << 16) * 9) >> 18;
gfx_draw_string_left(dpi, STR_AVERAGE_SPEED, &speed, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
}
// Ride length
set_format_arg(0, rct_string_id, STR_RIDE_LENGTH_ENTRY);
set_format_arg(2, uint16_t, td6->ride_length);
gfx_draw_string_left_clipped(dpi, STR_TRACK_LIST_RIDE_LENGTH, gCommonFormatArgs, COLOUR_BLACK, x, y, 214);
y += LIST_ROW_HEIGHT;
}
if (ride_type_has_flag(td6->type, RIDE_TYPE_FLAG_HAS_G_FORCES))
{
// Maximum positive vertical Gs
int32_t gForces = td6->max_positive_vertical_g * 32;
gfx_draw_string_left(dpi, STR_MAX_POSITIVE_VERTICAL_G, &gForces, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
// Maximum negative vertical Gs
gForces = td6->max_negative_vertical_g * 32;
gfx_draw_string_left(dpi, STR_MAX_NEGATIVE_VERTICAL_G, &gForces, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
// Maximum lateral Gs
gForces = td6->max_lateral_g * 32;
gfx_draw_string_left(dpi, STR_MAX_LATERAL_G, &gForces, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
// If .TD6
if (td6->version_and_colour_scheme / 4 >= 2)
{
if (td6->total_air_time != 0)
{
// Total air time
int32_t airTime = td6->total_air_time * 25;
gfx_draw_string_left(dpi, STR_TOTAL_AIR_TIME, &airTime, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
}
}
}
if (ride_type_has_flag(td6->type, RIDE_TYPE_FLAG_HAS_DROPS))
{
// Drops
uint16_t drops = td6->drops & 0x3F;
gfx_draw_string_left(dpi, STR_DROPS, &drops, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
// Drop height is multiplied by 0.75
gfx_draw_string_left(dpi, STR_HIGHEST_DROP_HEIGHT, &drops, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
}
if (td6->type != RIDE_TYPE_MINI_GOLF)
{
uint16_t inversions = td6->inversions & 0x1F;
if (inversions != 0)
{
// Inversions
gfx_draw_string_left(dpi, STR_INVERSIONS, &inversions, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
}
}
y += 4;
if (td6->space_required_x != 0xFF)
{
// Space required
set_format_arg(0, uint16_t, td6->space_required_x);
set_format_arg(2, uint16_t, td6->space_required_y);
gfx_draw_string_left(dpi, STR_TRACK_LIST_SPACE_REQUIRED, gCommonFormatArgs, COLOUR_BLACK, x, y);
y += LIST_ROW_HEIGHT;
}
if (td6->cost != 0)
{
gfx_draw_string_left(dpi, STR_TRACK_LIST_COST_AROUND, &td6->cost, COLOUR_BLACK, x, y);
}
}
/**
*
* rct2: 0x006850BD
*/
static void window_editor_inventions_list_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi, int32_t scrollIndex)
{
// Draw background
uint8_t paletteIndex = ColourMapA[w->colours[1]].mid_light;
gfx_clear(dpi, paletteIndex);
rct_research_item* researchItem = gResearchItems;
int32_t researchItemEndMarker;
if (scrollIndex == 1)
{
// Skip pre-researched items
for (; researchItem->rawValue != RESEARCHED_ITEMS_SEPARATOR; researchItem++)
{
}
researchItem++;
researchItemEndMarker = RESEARCHED_ITEMS_END;
}
else
{
researchItemEndMarker = RESEARCHED_ITEMS_SEPARATOR;
}
int16_t boxWidth = (w->widgets[WIDX_RESEARCH_ORDER_SCROLL].right - w->widgets[WIDX_RESEARCH_ORDER_SCROLL].left);
int16_t columnSplitOffset = boxWidth / 2;
int32_t itemY = -SCROLLABLE_ROW_HEIGHT;
do
{
itemY += SCROLLABLE_ROW_HEIGHT;
if (itemY + SCROLLABLE_ROW_HEIGHT < dpi->y || itemY >= dpi->y + dpi->height)
continue;
if (w->research_item == researchItem)
{
int32_t top, bottom;
if (_editorInventionsListDraggedItem == nullptr)
{
// Highlight
top = itemY;
bottom = itemY + SCROLLABLE_ROW_HEIGHT - 1;
}
else
{
// Drop horizontal rule
top = itemY - 1;
bottom = itemY;
}
gfx_filter_rect(dpi, 0, top, boxWidth, bottom, PALETTE_DARKEN_1);
}
if (researchItem->rawValue == RESEARCHED_ITEMS_SEPARATOR || researchItem->rawValue == RESEARCHED_ITEMS_END)
continue;
if (researchItem == _editorInventionsListDraggedItem)
continue;
utf8 groupNameBuffer[256], vehicleNameBuffer[256];
utf8* groupNamePtr = groupNameBuffer;
utf8* vehicleNamePtr = vehicleNameBuffer;
uint8_t colour;
if (research_item_is_always_researched(researchItem))
{
if (w->research_item == researchItem && _editorInventionsListDraggedItem == nullptr)
gCurrentFontSpriteBase = FONT_SPRITE_BASE_MEDIUM_EXTRA_DARK;
else
gCurrentFontSpriteBase = FONT_SPRITE_BASE_MEDIUM_DARK;
colour = w->colours[1] | COLOUR_FLAG_INSET;
}
else
{
// TODO: this is actually just a black colour.
colour = COLOUR_BRIGHT_GREEN | COLOUR_FLAG_TRANSLUCENT;
gCurrentFontSpriteBase = FONT_SPRITE_BASE_MEDIUM;
groupNamePtr = utf8_write_codepoint(groupNamePtr, colour);
vehicleNamePtr = utf8_write_codepoint(vehicleNamePtr, colour);
}
rct_string_id itemNameId = research_item_get_name(researchItem);
if (researchItem->type == RESEARCH_ENTRY_TYPE_RIDE
&& !RideGroupManager::RideTypeIsIndependent(researchItem->baseRideType))
{
const auto rideEntry = get_ride_entry(researchItem->entryIndex);
const rct_string_id rideGroupName = get_ride_naming(researchItem->baseRideType, rideEntry).name;
format_string(
groupNamePtr, std::size(groupNameBuffer), STR_INVENTIONS_LIST_RIDE_AND_VEHICLE_NAME, (void*)&rideGroupName);
format_string(vehicleNamePtr, std::size(vehicleNameBuffer), itemNameId, nullptr);
}
else
{
format_string(groupNamePtr, std::size(groupNameBuffer), itemNameId, nullptr);
vehicleNamePtr = nullptr;
}
// Draw group name
gfx_clip_string(groupNameBuffer, columnSplitOffset);
gfx_draw_string(dpi, groupNameBuffer, colour, 1, itemY);
// Draw vehicle name
if (vehicleNamePtr)
{
gfx_clip_string(vehicleNameBuffer, columnSplitOffset - 11);
gfx_draw_string(dpi, vehicleNameBuffer, colour, columnSplitOffset + 1, itemY);
}
} while (researchItem++->rawValue != researchItemEndMarker);
}
/**
*
* rct2: 0x006848D4
*/
void research_finish_item(rct_research_item* researchItem)
{
gResearchLastItem = *researchItem;
research_invalidate_related_windows();
if (researchItem->type == RESEARCH_ENTRY_TYPE_RIDE)
{
// Ride
uint32_t base_ride_type = researchItem->baseRideType;
int32_t rideEntryIndex = researchItem->entryIndex;
rct_ride_entry* rideEntry = get_ride_entry(rideEntryIndex);
if (rideEntry != nullptr && base_ride_type != RIDE_TYPE_NULL)
{
bool ride_group_was_invented_before = false;
bool ride_type_was_invented_before = ride_type_is_invented(base_ride_type);
rct_string_id availabilityString;
// Determine if the ride group this entry belongs to was invented before.
if (RideGroupManager::RideTypeHasRideGroups(base_ride_type))
{
const RideGroup* rideGroup = RideGroupManager::GetRideGroup(base_ride_type, rideEntry);
if (rideGroup->IsInvented())
{
ride_group_was_invented_before = true;
}
}
ride_type_set_invented(base_ride_type);
openrct2_assert(
base_ride_type < std::size(RideTypePossibleTrackConfigurations), "Invalid base_ride_type = %d", base_ride_type);
ride_entry_set_invented(rideEntryIndex);
bool seenRideEntry[MAX_RIDE_OBJECTS]{};
rct_research_item* researchItem2 = gResearchItems;
for (; researchItem2->rawValue != RESEARCHED_ITEMS_END; researchItem2++)
{
if (researchItem2->rawValue != RESEARCHED_ITEMS_SEPARATOR && researchItem2->type == RESEARCH_ENTRY_TYPE_RIDE)
{
uint8_t index = researchItem2->entryIndex;
seenRideEntry[index] = true;
}
}
// RCT2 made non-separated vehicles available at once, by removing all but one from research.
// To ensure old files keep working, look for ride entries not in research, and make them available as well.
for (int32_t i = 0; i < MAX_RIDE_OBJECTS; i++)
{
if (!seenRideEntry[i])
{
rct_ride_entry* rideEntry2 = get_ride_entry(i);
if (rideEntry2 != nullptr)
{
for (uint8_t j = 0; j < MAX_RIDE_TYPES_PER_RIDE_ENTRY; j++)
{
if (rideEntry2->ride_type[j] == base_ride_type)
{
ride_entry_set_invented(i);
break;
}
}
}
}
}
// If a vehicle should be listed separately (maze, mini golf, flat rides, shops)
if (RideGroupManager::RideTypeIsIndependent(base_ride_type))
{
availabilityString = STR_NEWS_ITEM_RESEARCH_NEW_RIDE_AVAILABLE;
set_format_arg(0, rct_string_id, rideEntry->naming.name);
}
// If a vehicle is the first to be invented for its ride group, show the ride group name.
else if (
!ride_type_was_invented_before
|| (RideGroupManager::RideTypeHasRideGroups(base_ride_type) && !ride_group_was_invented_before))
{
rct_ride_name naming = get_ride_naming(base_ride_type, rideEntry);
availabilityString = STR_NEWS_ITEM_RESEARCH_NEW_RIDE_AVAILABLE;
set_format_arg(0, rct_string_id, naming.name);
}
// If the vehicle should not be listed separately and it isn't the first to be invented for its ride group,
// report it as a new vehicle for the existing ride group.
else
{
availabilityString = STR_NEWS_ITEM_RESEARCH_NEW_VEHICLE_AVAILABLE;
rct_ride_name baseRideNaming = get_ride_naming(base_ride_type, rideEntry);
set_format_arg(0, rct_string_id, baseRideNaming.name);
set_format_arg(2, rct_string_id, rideEntry->naming.name);
}
if (!gSilentResearch)
{
if (gConfigNotifications.ride_researched)
{
news_item_add_to_queue(NEWS_ITEM_RESEARCH, availabilityString, researchItem->rawValue);
}
}
research_invalidate_related_windows();
}
}
else
{
// Scenery
rct_scenery_group_entry* sceneryGroupEntry = get_scenery_group_entry(researchItem->entryIndex);
if (sceneryGroupEntry != nullptr)
{
scenery_group_set_invented(researchItem->entryIndex);
set_format_arg(0, rct_string_id, sceneryGroupEntry->name);
if (!gSilentResearch)
{
if (gConfigNotifications.ride_researched)
{
news_item_add_to_queue(
NEWS_ITEM_RESEARCH, STR_NEWS_ITEM_RESEARCH_NEW_SCENERY_SET_AVAILABLE, researchItem->rawValue);
}
}
research_invalidate_related_windows();
init_scenery();
}
}
}
