mirrors
/
OpenRCT2
mirror of https://github.com/OpenRCT2/OpenRCT2.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Move everything to research vectors

This commit is contained in:
Gymnasiast 2019-06-16 23:32:31 +02:00
parent c3fdb728d1
commit b1fb75e496
No known key found for this signature in database
GPG Key ID: DBFFF47AB2CA3EDD
5 changed files with 198 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
src/openrct2-ui/windows/EditorInventionsList.cpp
View File

@ -242,26 +242,20 @@ static void move_research_item(ResearchItem* beforeItem)
*/
static ResearchItem* window_editor_inventions_list_get_item_from_scroll_y(int32_t scrollIndex, int32_t y)
{
ResearchItem* researchItem;
researchItem = gResearchItems;
auto begin = gResearchItemsInvented.begin();
auto end = gResearchItemsInvented.end();
if (scrollIndex != 0)
{
// Skip pre-researched items
for (; researchItem->rawValue != RESEARCHED_ITEMS_SEPARATOR; researchItem++)
{
}
researchItem++;
begin = gResearchItemsUninvented.begin();
end = gResearchItemsUninvented.end();
}
for (; researchItem->rawValue != RESEARCHED_ITEMS_SEPARATOR && researchItem->rawValue != RESEARCHED_ITEMS_END;
researchItem++)
for (auto it = begin; it != end; it++)
{
y -= SCROLLABLE_ROW_HEIGHT;
if (y < 0)
{
return researchItem;
return &*it;
}
}
@ -274,30 +268,24 @@ static ResearchItem* window_editor_inventions_list_get_item_from_scroll_y(int32_
*/
static ResearchItem* window_editor_inventions_list_get_item_from_scroll_y_include_seps(int32_t scrollIndex, int32_t y)
{
ResearchItem* researchItem;
researchItem = gResearchItems;
auto begin = gResearchItemsInvented.begin();
auto end = gResearchItemsInvented.end();
if (scrollIndex != 0)
{
// Skip pre-researched items
for (; researchItem->rawValue != RESEARCHED_ITEMS_SEPARATOR; researchItem++)
{
}
researchItem++;
begin = gResearchItemsUninvented.begin();
end = gResearchItemsUninvented.end();
}
for (; researchItem->rawValue != RESEARCHED_ITEMS_SEPARATOR && researchItem->rawValue != RESEARCHED_ITEMS_END;
researchItem++)
for (auto it = begin; it != end; it++)
{
y -= SCROLLABLE_ROW_HEIGHT;
if (y < 0)
{
return researchItem;
return &*it;
}
}
return researchItem;
return &*(end - 1);
}
static ResearchItem* get_research_item_at(int32_t x, int32_t y)
@ -443,22 +431,14 @@ static void window_editor_inventions_list_update(rct_window* w)
*/
static void window_editor_inventions_list_scrollgetheight(rct_window* w, int32_t scrollIndex, int32_t* width, int32_t* height)
{
ResearchItem* researchItem;
*height = 0;
// Count / skip pre-researched items
for (researchItem = gResearchItems; researchItem->rawValue != RESEARCHED_ITEMS_SEPARATOR; researchItem++)
*height += SCROLLABLE_ROW_HEIGHT;
if (scrollIndex == 1)
if (scrollIndex == 0)
{
researchItem++;
// Count non pre-researched items
*height = 0;
for (; researchItem->rawValue != RESEARCHED_ITEMS_END; researchItem++)
*height += SCROLLABLE_ROW_HEIGHT;
*height += gResearchItemsInvented.size() * SCROLLABLE_ROW_HEIGHT;
}
else
{
*height += gResearchItemsUninvented.size() * SCROLLABLE_ROW_HEIGHT;
}
}
@ -676,21 +656,13 @@ static void window_editor_inventions_list_scrollpaint(rct_window* w, rct_drawpix
uint8_t paletteIndex = ColourMapA[w->colours[1]].mid_light;
gfx_clear(dpi, paletteIndex);
ResearchItem* researchItem = gResearchItems;
int32_t researchItemEndMarker;
auto it = gResearchItemsInvented.begin();
auto researchItemEndMarker = gResearchItemsInvented.end();
if (scrollIndex == 1)
{
// Skip pre-researched items
for (; researchItem->rawValue != RESEARCHED_ITEMS_SEPARATOR; researchItem++)
{
}
researchItem++;
researchItemEndMarker = RESEARCHED_ITEMS_END;
}
else
{
researchItemEndMarker = RESEARCHED_ITEMS_SEPARATOR;
it = gResearchItemsUninvented.begin();
researchItemEndMarker = gResearchItemsUninvented.end();
}
int16_t boxWidth = (w->widgets[WIDX_RESEARCH_ORDER_SCROLL].right - w->widgets[WIDX_RESEARCH_ORDER_SCROLL].left);
@ -698,6 +670,7 @@ static void window_editor_inventions_list_scrollpaint(rct_window* w, rct_drawpix
int32_t itemY = -SCROLLABLE_ROW_HEIGHT;
do
{
ResearchItem* researchItem = &*it;
itemY += SCROLLABLE_ROW_HEIGHT;
if (itemY + SCROLLABLE_ROW_HEIGHT < dpi->y || itemY >= dpi->y + dpi->height)
continue;
@ -721,9 +694,6 @@ static void window_editor_inventions_list_scrollpaint(rct_window* w, rct_drawpix
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;
@ -777,7 +747,7 @@ static void window_editor_inventions_list_scrollpaint(rct_window* w, rct_drawpix
gfx_clip_string(vehicleNameBuffer, columnSplitOffset - 11);
gfx_draw_string(dpi, vehicleNameBuffer, colour, columnSplitOffset + 1, itemY);
}
} while (researchItem++->rawValue != researchItemEndMarker);
} while (it++ != researchItemEndMarker);
}
#pragma region Drag item
@ -856,7 +826,7 @@ static void window_editor_inventions_list_drag_moved(rct_window* w, int32_t x, i
{
researchItem = get_research_item_at(x, y);
y += LIST_ROW_HEIGHT;
} while (researchItem != nullptr && researchItem->rawValue >= 0 && research_item_is_always_researched(researchItem));
} while (researchItem != nullptr && research_item_is_always_researched(researchItem));
if (researchItem != nullptr)
move_research_item(researchItem);

358
src/openrct2/management/Research.cpp
View File

@ -53,6 +53,8 @@ ResearchItem gResearchNextItem;
// 0x01358844[500]
ResearchItem gResearchItems[MAX_RESEARCH_ITEMS];
std::vector<ResearchItem> gResearchItemsUninvented;
std::vector<ResearchItem> gResearchItemsInvented;
// 0x00EE787C
uint8_t gResearchUncompletedCategories;
@ -69,9 +71,8 @@ bool gSilentResearch = false;
*/
void research_reset_items()
{
gResearchItems[0].rawValue = RESEARCHED_ITEMS_SEPARATOR;
gResearchItems[1].rawValue = RESEARCHED_ITEMS_END;
gResearchItems[2].rawValue = RESEARCHED_ITEMS_END_2;
gResearchItemsUninvented.clear();
gResearchItemsInvented.clear();
}
/**
@ -81,13 +82,10 @@ void research_reset_items()
void research_update_uncompleted_types()
{
int32_t uncompletedResearchTypes = 0;
ResearchItem* researchItem = gResearchItems;
while (researchItem++->rawValue != RESEARCHED_ITEMS_SEPARATOR)
;
for (; researchItem->rawValue != RESEARCHED_ITEMS_END; researchItem++)
for (auto const& researchItem : gResearchItemsUninvented)
{
uncompletedResearchTypes |= (1 << researchItem->category);
uncompletedResearchTypes |= (1 << researchItem.category);
}
gResearchUncompletedCategories = uncompletedResearchTypes;
@ -133,27 +131,24 @@ static void research_invalidate_related_windows()
*/
static void research_next_design()
{
ResearchItem *firstUnresearchedItem, *researchItem, tmp;
int32_t ignoreActiveResearchTypes;
// Skip already researched items
firstUnresearchedItem = gResearchItems;
while (firstUnresearchedItem->rawValue != RESEARCHED_ITEMS_SEPARATOR)
if (gResearchItemsUninvented.empty())
{
firstUnresearchedItem++;
return;
}
ignoreActiveResearchTypes = 0;
researchItem = firstUnresearchedItem;
ResearchItem researchItem;
bool ignoreActiveResearchTypes = false;
auto it = gResearchItemsUninvented.begin();
for (;;)
{
researchItem++;
if (researchItem->rawValue == RESEARCHED_ITEMS_END)
researchItem = *it;
if (it == gResearchItemsUninvented.end())
{
if (!ignoreActiveResearchTypes)
{
ignoreActiveResearchTypes = 1;
researchItem = firstUnresearchedItem;
ignoreActiveResearchTypes = true;
it = gResearchItemsUninvented.begin();
continue;
}
else
@ -167,24 +162,19 @@ static void research_next_design()
return;
}
}
else if (ignoreActiveResearchTypes || (gResearchPriorities & (1 << researchItem->category)))
else if (ignoreActiveResearchTypes || (gResearchPriorities & (1 << researchItem.category)))
{
break;
}
it++;
}
gResearchNextItem = *researchItem;
gResearchNextItem = researchItem;
gResearchProgress = 0;
gResearchProgressStage = RESEARCH_STAGE_DESIGNING;
// Bubble research item up until it is above the researched items separator
do
{
tmp = *researchItem;
*researchItem = *(researchItem - 1);
*(researchItem - 1) = tmp;
researchItem--;
} while ((researchItem + 1)->rawValue != RESEARCHED_ITEMS_SEPARATOR);
gResearchItemsUninvented.erase(it);
gResearchItemsInvented.push_back(researchItem);
research_invalidate_related_windows();
}
@ -229,15 +219,15 @@ void research_finish_item(ResearchItem* researchItem)
ride_entry_set_invented(rideEntryIndex);
bool seenRideEntry[MAX_RIDE_OBJECTS]{};
ResearchItem* researchItem2 = gResearchItems;
for (; researchItem2->rawValue != RESEARCHED_ITEMS_END; researchItem2++)
for (auto const& researchItem3 : gResearchItemsUninvented)
{
if (researchItem2->rawValue != RESEARCHED_ITEMS_SEPARATOR && researchItem2->type == RESEARCH_ENTRY_TYPE_RIDE)
{
uint8_t index = researchItem2->entryIndex;
seenRideEntry[index] = true;
}
uint8_t index = researchItem3.entryIndex;
seenRideEntry[index] = true;
}
for (auto const& researchItem3 : gResearchItemsInvented)
{
uint8_t index = researchItem3.entryIndex;
seenRideEntry[index] = true;
}
// RCT2 made non-separated vehicles available at once, by removing all but one from research.
@ -386,54 +376,12 @@ void research_update()
}
}
void research_process_random_items()
{
ResearchItem* research = gResearchItems;
for (; research->rawValue != RESEARCHED_ITEMS_END; research++)
{
}
research++;
for (; research->rawValue != RESEARCHED_ITEMS_END_2; research += 2)
{
if (scenario_rand() & 1)
{
continue;
}
ResearchItem* edx = nullptr;
ResearchItem* ebp = nullptr;
ResearchItem* inner_research = gResearchItems;
do
{
if (research->rawValue == inner_research->rawValue)
{
edx = inner_research;
}
if ((research + 1)->rawValue == inner_research->rawValue)
{
ebp = inner_research;
}
} while ((inner_research++)->rawValue != RESEARCHED_ITEMS_END);
assert(edx != nullptr);
edx->rawValue = research->rawValue;
assert(ebp != nullptr);
ebp->rawValue = (research + 1)->rawValue;
uint8_t cat = edx->category;
edx->category = ebp->category;
ebp->category = cat;
}
}
/**
*
* rct2: 0x00684AC3
*/
void research_reset_current_item()
{
research_process_random_items();
set_every_ride_type_not_invented();
set_every_ride_entry_not_invented();
@ -441,9 +389,9 @@ void research_reset_current_item()
set_all_scenery_items_invented();
set_all_scenery_groups_not_invented();
for (ResearchItem* research = gResearchItems; research->rawValue != RESEARCHED_ITEMS_SEPARATOR; research++)
for (auto& researchItem : gResearchItemsInvented)
{
research_finish_item(research);
research_finish_item(&researchItem);
}
gResearchLastItem.rawValue = RESEARCHED_ITEMS_SEPARATOR;
@ -455,29 +403,9 @@ void research_reset_current_item()
*
* rct2: 0x006857FA
*/
static void research_insert_unresearched(int32_t rawValue, int32_t category)
static void research_insert_unresearched(int32_t rawValue, uint8_t category)
{
ResearchItem *researchItem, *researchItem2;
researchItem = gResearchItems;
do
{
if (researchItem->rawValue == RESEARCHED_ITEMS_END)
{
// Insert slot
researchItem2 = researchItem;
while (researchItem2->rawValue != RESEARCHED_ITEMS_END_2)
{
researchItem2++;
}
memmove(researchItem + 1, researchItem, (researchItem2 - researchItem + 1) * sizeof(ResearchItem));
// Place new item
researchItem->rawValue = rawValue;
researchItem->category = category;
break;
}
} while (rawValue != (researchItem++)->rawValue);
gResearchItemsUninvented.push_back({ rawValue, category });
}
/**
@ -486,36 +414,14 @@ static void research_insert_unresearched(int32_t rawValue, int32_t category)
*/
static void research_insert_researched(int32_t rawValue, uint8_t category)
{
ResearchItem *researchItem, *researchItem2;
researchItem = gResearchItems;
// First check to make sure that entry is not already accounted for
for (; researchItem->rawValue != RESEARCHED_ITEMS_END; researchItem++)
ResearchItem item = { rawValue, category };
if (item.Exists())
{
if ((researchItem->rawValue & 0xFFFFFF) == (rawValue & 0xFFFFFF))
{
return;
}
return;
}
researchItem = gResearchItems;
do
{
if (researchItem->rawValue == RESEARCHED_ITEMS_SEPARATOR)
{
// Insert slot
researchItem2 = researchItem;
while (researchItem2->rawValue != RESEARCHED_ITEMS_END_2)
{
researchItem2++;
}
memmove(researchItem + 1, researchItem, (researchItem2 - researchItem + 1) * sizeof(ResearchItem));
// Place new item
researchItem->rawValue = rawValue;
researchItem->category = category;
break;
}
} while (rawValue != (researchItem++)->rawValue);
gResearchItemsInvented.push_back(item);
}
/**
@ -524,17 +430,24 @@ static void research_insert_researched(int32_t rawValue, uint8_t category)
*/
void research_remove(ResearchItem* researchItem)
{
for (ResearchItem* researchItem2 = gResearchItems; researchItem2->rawValue != RESEARCHED_ITEMS_END; researchItem2++)
for (auto it = gResearchItemsUninvented.begin(); it != gResearchItemsUninvented.end(); it++)
{
if (researchItem2->rawValue == researchItem->rawValue)
auto& researchItem2 = *it;
if (researchItem2.Equals(researchItem))
{
do
{
*researchItem2 = *(researchItem2 + 1);
} while (researchItem2++->rawValue != RESEARCHED_ITEMS_END_2);
gResearchItemsUninvented.erase(it);
return;
}
}
for (auto it = gResearchItemsInvented.begin(); it != gResearchItemsInvented.end(); it++)
{
auto& researchItem2 = *it;
if (researchItem2.Equals(researchItem))
{
return;
}
gResearchItemsInvented.erase(it);
}
}
void research_insert(int32_t researched, int32_t rawValue, uint8_t category)
@ -821,54 +734,76 @@ rct_string_id research_get_friendly_base_ride_type_name(uint8_t trackType, rct_r
*
* rct2: 0x00685A79
* Do not use the research list outside of the inventions list window with the flags
* Clears flags like "always researched".
*/
void research_remove_flags()
{
for (ResearchItem* research = gResearchItems; research->rawValue != RESEARCHED_ITEMS_END_2; research++)
for (auto& researchItem : gResearchItemsUninvented)
{
// Clear the always researched flags.
if (research->rawValue > RESEARCHED_ITEMS_SEPARATOR)
{
research->flags = 0;
}
researchItem.flags = 0;
}
for (auto& researchItem : gResearchItemsInvented)
{
researchItem.flags = 0;
}
}
void research_fix()
{
// Fix invalid research items
for (int32_t i = 0; i < MAX_RESEARCH_ITEMS; i++)
for (auto it = gResearchItemsInvented.begin(); it != gResearchItemsInvented.end();)
{
ResearchItem* researchItem = &gResearchItems[i];
if (researchItem->rawValue == RESEARCHED_ITEMS_SEPARATOR)
continue;
if (researchItem->rawValue == RESEARCHED_ITEMS_END)
auto& researchItem = *it;
if (researchItem.type == RESEARCH_ENTRY_TYPE_RIDE)
{
if (i == MAX_RESEARCH_ITEMS - 1)
{
(--researchItem)->rawValue = RESEARCHED_ITEMS_END;
}
(++researchItem)->rawValue = RESEARCHED_ITEMS_END_2;
break;
}
if (researchItem->rawValue == RESEARCHED_ITEMS_END_2)
break;
if (researchItem->type == RESEARCH_ENTRY_TYPE_RIDE)
{
rct_ride_entry* rideEntry = get_ride_entry(researchItem->entryIndex);
rct_ride_entry* rideEntry = get_ride_entry(researchItem.entryIndex);
if (rideEntry == nullptr)
{
research_remove(researchItem);
i--;
gResearchItemsInvented.erase(it);
}
else
{
it++;
}
}
else
{
rct_scenery_group_entry* sceneryGroupEntry = get_scenery_group_entry(researchItem->rawValue);
rct_scenery_group_entry* sceneryGroupEntry = get_scenery_group_entry(researchItem.rawValue);
if (sceneryGroupEntry == nullptr)
{
research_remove(researchItem);
i--;
gResearchItemsInvented.erase(it);
}
else
{
it++;
}
}
}
for (auto it = gResearchItemsUninvented.begin(); it != gResearchItemsUninvented.end();)
{
auto& researchItem = *it;
if (researchItem.type == RESEARCH_ENTRY_TYPE_RIDE)
{
rct_ride_entry* rideEntry = get_ride_entry(researchItem.entryIndex);
if (rideEntry == nullptr)
{
gResearchItemsUninvented.erase(it);
}
else
{
it++;
}
}
else
{
rct_scenery_group_entry* sceneryGroupEntry = get_scenery_group_entry(researchItem.rawValue);
if (sceneryGroupEntry == nullptr)
{
gResearchItemsUninvented.erase(it);
}
else
{
it++;
}
}
}
@ -914,50 +849,19 @@ void research_fix()
void research_items_make_all_unresearched()
{
ResearchItem *researchItem, *nextResearchItem, researchItemTemp;
int32_t sorted;
do
for (auto it = gResearchItemsInvented.begin(); it != gResearchItemsInvented.end();)
{
sorted = 1;
for (researchItem = gResearchItems; researchItem->rawValue != RESEARCHED_ITEMS_SEPARATOR; researchItem++)
{
if (research_item_is_always_researched(researchItem))
continue;
nextResearchItem = researchItem + 1;
if (nextResearchItem->rawValue == RESEARCHED_ITEMS_SEPARATOR
|| research_item_is_always_researched(nextResearchItem))
{
// Bubble up always researched item or separator
researchItemTemp = *researchItem;
*researchItem = *nextResearchItem;
*nextResearchItem = researchItemTemp;
sorted = 0;
if (researchItem->rawValue == RESEARCHED_ITEMS_SEPARATOR)
break;
}
}
} while (!sorted);
auto& researchItem = *it;
gResearchItemsUninvented.push_back(researchItem);
}
}
void research_items_make_all_researched()
{
ResearchItem *researchItem, researchItemTemp;
// Find separator
for (researchItem = gResearchItems; researchItem->rawValue != RESEARCHED_ITEMS_SEPARATOR; researchItem++)
for (auto it = gResearchItemsUninvented.begin(); it != gResearchItemsUninvented.end();)
{
}
// Move separator below all items
for (; (researchItem + 1)->rawValue != RESEARCHED_ITEMS_END; researchItem++)
{
// Swap separator with research item
researchItemTemp = *researchItem;
*researchItem = *(researchItem + 1);
*(researchItem + 1) = researchItemTemp;
auto& researchItem = *it;
gResearchItemsInvented.push_back(researchItem);
}
}
@ -967,31 +871,19 @@ void research_items_make_all_researched()
*/
void research_items_shuffle()
{
ResearchItem *researchItem, *researchOrderBase, researchItemTemp;
int32_t i, numNonResearchedItems;
// Skip pre-researched items
for (researchItem = gResearchItems; researchItem->rawValue != RESEARCHED_ITEMS_SEPARATOR; researchItem++)
{
}
researchItem++;
researchOrderBase = researchItem;
// Count non pre-researched items
numNonResearchedItems = 0;
for (; researchItem->rawValue != RESEARCHED_ITEMS_END; researchItem++)
numNonResearchedItems++;
size_t numNonResearchedItems = gResearchItemsUninvented.size();
// Shuffle list
for (i = 0; i < numNonResearchedItems; i++)
for (size_t i = 0; i < numNonResearchedItems; i++)
{
int32_t ri = util_rand() % numNonResearchedItems;
size_t ri = util_rand() % numNonResearchedItems;
if (ri == i)
continue;
researchItemTemp = researchOrderBase[i];
researchOrderBase[i] = researchOrderBase[ri];
researchOrderBase[ri] = researchItemTemp;
ResearchItem researchItemTemp = gResearchItemsUninvented[i];
gResearchItemsUninvented[i] = gResearchItemsUninvented[ri];
gResearchItemsUninvented[ri] = researchItemTemp;
}
}
@ -1006,3 +898,27 @@ bool ResearchItem::IsInventedEndMarker() const
{
return rawValue == RESEARCHED_ITEMS_SEPARATOR;
}
bool ResearchItem::Equals(const ResearchItem* otherItem) const
{
return (entryIndex == otherItem->entryIndex && baseRideType == otherItem->baseRideType && type == otherItem->type);
}
bool ResearchItem::Exists() const
{
for (auto const& researchItem : gResearchItemsUninvented)
{
if (researchItem.Equals(this))
{
return true;
}
}
for (auto const& researchItem : gResearchItemsInvented)
{
if (researchItem.Equals(this))
{
return true;
}
}
return false;
}

6
src/openrct2/management/Research.h
View File

@ -35,6 +35,8 @@ struct ResearchItem
bool IsInventedEndMarker() const;
bool IsRandomEndMarker() const;
bool IsUninventedEndMarker() const;
bool Equals(const ResearchItem* otherItem) const;
bool Exists() const;
};
assert_struct_size(ResearchItem, 5);
#pragma pack(pop)
@ -103,7 +105,8 @@ extern uint8_t gResearchExpectedDay;
extern ResearchItem gResearchLastItem;
extern ResearchItem gResearchNextItem;
extern ResearchItem gResearchItems[MAX_RESEARCH_ITEMS];
extern std::vector<ResearchItem> gResearchItemsUninvented;
extern std::vector<ResearchItem> gResearchItemsInvented;
extern uint8_t gResearchUncompletedCategories;
extern bool gSilentResearch;
@ -113,7 +116,6 @@ void research_update();
void research_reset_current_item();
void research_populate_list_random();
void research_populate_list_researched();
void research_process_random_items();
void research_finish_item(ResearchItem* researchItem);
void research_insert(int32_t researched, int32_t rawValue, uint8_t category);

13
src/openrct2/rct2/S6Exporter.cpp
View File

@ -848,7 +848,18 @@ void S6Exporter::ExportResearchedSceneryItems()
void S6Exporter::ExportResearchList()
{
std::memcpy(_s6.research_items, gResearchItems, sizeof(_s6.research_items));
size_t i = 0;
for (const auto& researchItem : gResearchItemsInvented)
{
_s6.research_items[i++] = RCT12ResearchItem{ researchItem.rawValue, researchItem.category };
}
_s6.research_items[i++] = { RCT12_RESEARCHED_ITEMS_SEPARATOR, 0 };
for (const auto& researchItem : gResearchItemsUninvented)
{
_s6.research_items[i++] = RCT12ResearchItem{ researchItem.rawValue, researchItem.category };
}
_s6.research_items[i++] = { RCT12_RESEARCHED_ITEMS_END, 0 };
_s6.research_items[i] = { RCT12_RESEARCHED_ITEMS_END_2, 0 };
}
void S6Exporter::ExportMarketingCampaigns()

20
src/openrct2/rct2/S6Importer.cpp
View File

@ -850,7 +850,25 @@ public:
void ImportResearchList()
{
std::memcpy(gResearchItems, _s6.research_items, sizeof(_s6.research_items));
bool invented = true;
for (size_t i = 0; i < sizeof(_s6.research_items); i++)
{
if (_s6.research_items[i].IsInventedEndMarker())
{
invented = false;
continue;
}
else if (_s6.research_items[i].IsUninventedEndMarker() || _s6.research_items[i].IsRandomEndMarker())
{
break;
}
RCT12ResearchItem* ri = &_s6.research_items[i];
if (invented)
gResearchItemsInvented.push_back(ResearchItem{ ri->rawValue, ri->category });
else
gResearchItemsUninvented.push_back(ResearchItem{ ri->rawValue, ri->category });
}
}
void ImportBanner(Banner* dst, const RCT12Banner* src)