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

Make terminology use more consistent

This commit is contained in:
Michael Steenbeek 2017-11-20 10:15:52 +01:00
parent 38024bbd0d
commit bf69b2e682
38 changed files with 158 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
OpenRCT2.xcodeproj/project.pbxproj
View File

@ -375,7 +375,7 @@
F76C868B1EC4E88400FA49E2 /* tile_element.c in Sources */ = {isa = PBXBuildFile; fileRef = F76C843F1EC4E7CC00FA49E2 /* tile_element.c */; };
F76C868D1EC4E88400FA49E2 /* path.c in Sources */ = {isa = PBXBuildFile; fileRef = F76C84411EC4E7CC00FA49E2 /* path.c */; };
F76C868E1EC4E88400FA49E2 /* scenery.c in Sources */ = {isa = PBXBuildFile; fileRef = F76C84421EC4E7CC00FA49E2 /* scenery.c */; };
F76C868F1EC4E88400FA49E2 /* scenery_multiple.c in Sources */ = {isa = PBXBuildFile; fileRef = F76C84431EC4E7CC00FA49E2 /* scenery_multiple.c */; };
F76C868F1EC4E88400FA49E2 /* large_scenery.c in Sources */ = {isa = PBXBuildFile; fileRef = F76C84431EC4E7CC00FA49E2 /* large_scenery.c */; };
F76C86901EC4E88400FA49E2 /* surface.c in Sources */ = {isa = PBXBuildFile; fileRef = F76C84441EC4E7CC00FA49E2 /* surface.c */; };
F76C86921EC4E88400FA49E2 /* Paint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F76C84461EC4E7CC00FA49E2 /* Paint.cpp */; };
F76C86941EC4E88400FA49E2 /* paint_helpers.c in Sources */ = {isa = PBXBuildFile; fileRef = F76C84481EC4E7CC00FA49E2 /* paint_helpers.c */; };
@ -1259,7 +1259,7 @@
F76C84401EC4E7CC00FA49E2 /* tile_element.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = tile_element.h; sourceTree = "<group>"; };
F76C84411EC4E7CC00FA49E2 /* path.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = path.c; sourceTree = "<group>"; };
F76C84421EC4E7CC00FA49E2 /* scenery.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = scenery.c; sourceTree = "<group>"; };
F76C84431EC4E7CC00FA49E2 /* scenery_multiple.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = scenery_multiple.c; sourceTree = "<group>"; };
F76C84431EC4E7CC00FA49E2 /* large_scenery.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = large_scenery.c; sourceTree = "<group>"; };
F76C84441EC4E7CC00FA49E2 /* surface.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = surface.c; sourceTree = "<group>"; };
F76C84451EC4E7CC00FA49E2 /* surface.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = surface.h; sourceTree = "<group>"; };
F76C84461EC4E7CC00FA49E2 /* Paint.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = Paint.cpp; sourceTree = "<group>"; };
@ -2215,7 +2215,7 @@
F76C84401EC4E7CC00FA49E2 /* tile_element.h */,
F76C84411EC4E7CC00FA49E2 /* path.c */,
F76C84421EC4E7CC00FA49E2 /* scenery.c */,
F76C84431EC4E7CC00FA49E2 /* scenery_multiple.c */,
F76C84431EC4E7CC00FA49E2 /* large_scenery.c */,
F76C84441EC4E7CC00FA49E2 /* surface.c */,
F76C84451EC4E7CC00FA49E2 /* surface.h */,
);
@ -3448,7 +3448,7 @@
F76C868B1EC4E88400FA49E2 /* tile_element.c in Sources */,
F76C868D1EC4E88400FA49E2 /* path.c in Sources */,
F76C868E1EC4E88400FA49E2 /* scenery.c in Sources */,
F76C868F1EC4E88400FA49E2 /* scenery_multiple.c in Sources */,
F76C868F1EC4E88400FA49E2 /* large_scenery.c in Sources */,
F76C86901EC4E88400FA49E2 /* surface.c in Sources */,
F76C86921EC4E88400FA49E2 /* Paint.cpp in Sources */,
F76C86941EC4E88400FA49E2 /* paint_helpers.c in Sources */,

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

@ -280,7 +280,7 @@ static void research_scenery_sets_setup(){
if (!find_object_in_entry_group(object, &entry_type, &entry_index))
continue;
if (entry_type != OBJECT_TYPE_SCENERY_SETS)
if (entry_type != OBJECT_TYPE_SCENERY_GROUP)
continue;
rct_research_item* research = gResearchItems;

8
src/openrct2-ui/windows/Map.cpp
View File

@ -1451,10 +1451,10 @@ static const uint16 ElementTypeMaskColour[] = {
0xFFFF, // TILE_ELEMENT_TYPE_SURFACE
0x0000, // TILE_ELEMENT_TYPE_PATH
0x00FF, // TILE_ELEMENT_TYPE_TRACK
0xFF00, // TILE_ELEMENT_TYPE_SCENERY
0xFF00, // TILE_ELEMENT_TYPE_SMALL_SCENERY
0x0000, // TILE_ELEMENT_TYPE_ENTRANCE
0xFFFF, // TILE_ELEMENT_TYPE_WALL
0x0000, // TILE_ELEMENT_TYPE_SCENERY_MULTIPLE
0x0000, // TILE_ELEMENT_TYPE_LARGE_SCENERY
0xFFFF, // TILE_ELEMENT_TYPE_BANNER
0x0000, // TILE_ELEMENT_TYPE_CORRUPT
};
@ -1463,10 +1463,10 @@ static const uint16 ElementTypeAddColour[] = {
MAP_COLOUR(PALETTE_INDEX_0), // TILE_ELEMENT_TYPE_SURFACE
MAP_COLOUR(PALETTE_INDEX_17), // TILE_ELEMENT_TYPE_PATH
MAP_COLOUR_2(PALETTE_INDEX_183, PALETTE_INDEX_0), // TILE_ELEMENT_TYPE_TRACK
MAP_COLOUR_2(PALETTE_INDEX_0, PALETTE_INDEX_99), // TILE_ELEMENT_TYPE_SCENERY
MAP_COLOUR_2(PALETTE_INDEX_0, PALETTE_INDEX_99), // TILE_ELEMENT_TYPE_SMALL_SCENERY
MAP_COLOUR(PALETTE_INDEX_186), // TILE_ELEMENT_TYPE_ENTRANCE
MAP_COLOUR(PALETTE_INDEX_0), // TILE_ELEMENT_TYPE_WALL
MAP_COLOUR(PALETTE_INDEX_99), // TILE_ELEMENT_TYPE_SCENERY_MULTIPLE
MAP_COLOUR(PALETTE_INDEX_99), // TILE_ELEMENT_TYPE_LARGE_SCENERY
MAP_COLOUR(PALETTE_INDEX_0), // TILE_ELEMENT_TYPE_BANNER
MAP_COLOUR(PALETTE_INDEX_68), // TILE_ELEMENT_TYPE_CORRUPT
};

2
src/openrct2-ui/windows/ObjectLoadError.cpp
View File

@ -132,7 +132,7 @@ static rct_string_id get_object_type_string(const rct_object_entry *entry)
case OBJECT_TYPE_PATH_BITS:
result = STR_OBJECT_SELECTION_PATH_EXTRAS;
break;
case OBJECT_TYPE_SCENERY_SETS:
case OBJECT_TYPE_SCENERY_GROUP:
result = STR_OBJECT_SELECTION_SCENERY_GROUPS;
break;
case OBJECT_TYPE_PARK_ENTRANCE:

12
src/openrct2-ui/windows/Scenery.cpp
View File

@ -239,13 +239,13 @@ void window_scenery_init()
if (scenerySetIndex == MAX_SCENERY_GROUP_OBJECTS)
continue;
rct_scenery_set_entry* scenerySetEntry = get_scenery_group_entry(scenerySetIndex);
if (scenerySetEntry == nullptr)
rct_scenery_group_entry* sceneryGroupEntry = get_scenery_group_entry(scenerySetIndex);
if (sceneryGroupEntry == nullptr)
continue;
sint32 sceneryTabEntryCount = 0;
for (sint32 i = 0; i < scenerySetEntry->entry_count; i++) {
uint16 sceneryEntryId = scenerySetEntry->scenery_entries[i];
for (sint32 i = 0; i < sceneryGroupEntry->entry_count; i++) {
uint16 sceneryEntryId = sceneryGroupEntry->scenery_entries[i];
if (scenery_is_invented(sceneryEntryId) || gCheatsIgnoreResearchStatus) {
window_scenery_tab_entries[scenerySetIndex][sceneryTabEntryCount] = sceneryEntryId;
window_scenery_tab_entries[scenerySetIndex][++sceneryTabEntryCount] = -1;
@ -316,7 +316,7 @@ void window_scenery_init()
sint32 usedValues = 0;
for (sint32 scenerySetId = 0; scenerySetId < MAX_SCENERY_GROUP_OBJECTS; scenerySetId++) {
rct_scenery_set_entry* sceneryEntry = get_scenery_group_entry(scenerySetId);
rct_scenery_group_entry* sceneryEntry = get_scenery_group_entry(scenerySetId);
if (sceneryEntry == nullptr)
continue;
@ -902,7 +902,7 @@ void window_scenery_invalidate(rct_window *w)
uint16 tabIndex = gWindowSceneryActiveTabIndex;
uint32 titleStringId = STR_MISCELLANEOUS;
if (tabIndex < SCENERY_WINDOW_TABS - 1) {
rct_scenery_set_entry * sgEntry = get_scenery_group_entry(tabIndex);
rct_scenery_group_entry * sgEntry = get_scenery_group_entry(tabIndex);
if (sgEntry != nullptr) {
titleStringId = sgEntry->name;
}

4
src/openrct2-ui/windows/Sign.cpp
View File

@ -164,7 +164,7 @@ rct_window * window_sign_open(rct_windownumber number)
while (1)
{
if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
{
rct_scenery_entry* scenery_entry = get_large_scenery_entry(scenery_large_get_type(tile_element));
if (scenery_entry->large_scenery.scrolling_mode != 0xFF)
@ -231,7 +231,7 @@ static void window_sign_mouseup(rct_window *w, rct_widgetindex widgetIndex)
case WIDX_SIGN_DEMOLISH:
while (1)
{
if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
{
rct_scenery_entry* scenery_entry = get_large_scenery_entry(scenery_large_get_type(tile_element));
if (scenery_entry->large_scenery.scrolling_mode != 0xFF)

2
src/openrct2/cheats.c
View File

@ -87,7 +87,7 @@ static void cheat_water_plants()
tile_element_iterator_begin(&it);
do {
if (tile_element_get_type(it.element) == TILE_ELEMENT_TYPE_SCENERY) {
if (tile_element_get_type(it.element) == TILE_ELEMENT_TYPE_SMALL_SCENERY) {
it.element->properties.scenery.age = 0;
}
} while (tile_element_iterator_next(&it));

2
src/openrct2/game.c
View File

@ -1137,7 +1137,7 @@ void game_fix_save_vars()
}
} else {
uint8 entryIndex = researchItem->entryIndex;
rct_scenery_set_entry *sceneryGroupEntry = get_scenery_group_entry(entryIndex);
rct_scenery_group_entry *sceneryGroupEntry = get_scenery_group_entry(entryIndex);
if (sceneryGroupEntry == NULL) {
research_remove(researchItem->entryIndex);
i--;

2
src/openrct2/interface/console.c
View File

@ -1171,7 +1171,7 @@ static sint32 cc_load_object(const utf8 **argv, sint32 argc) {
research_reset_current_item();
gSilentResearch = false;
}
else if (objectType == OBJECT_TYPE_SCENERY_SETS) {
else if (objectType == OBJECT_TYPE_SCENERY_GROUP) {
research_insert(true, groupIndex, RESEARCH_CATEGORY_SCENERYSET);
gSilentResearch = true;

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

@ -310,16 +310,16 @@ void research_finish_item(uint32 entryIndex)
else
{
// Scenery
rct_scenery_set_entry * scenerySetEntry = get_scenery_group_entry(entryIndex & 0xFFFF);
if (scenerySetEntry != nullptr)
rct_scenery_group_entry * sceneryGroupEntry = get_scenery_group_entry(entryIndex & 0xFFFF);
if (sceneryGroupEntry != nullptr)
{
for (sint32 i = 0; i < scenerySetEntry->entry_count; i++)
for (sint32 i = 0; i < sceneryGroupEntry->entry_count; i++)
{
sint32 subSceneryEntryIndex = scenerySetEntry->scenery_entries[i];
sint32 subSceneryEntryIndex = sceneryGroupEntry->scenery_entries[i];
gResearchedSceneryItems[subSceneryEntryIndex >> 5] |= 1UL << (subSceneryEntryIndex & 0x1F);
}
set_format_arg(0, rct_string_id, scenerySetEntry->name);
set_format_arg(0, rct_string_id, sceneryGroupEntry->name);
if (!gSilentResearch)
{
@ -447,7 +447,7 @@ void research_reset_current_item()
for (sint32 i = 0; i < MAX_SCENERY_GROUP_OBJECTS; ++i)
{
rct_scenery_set_entry * scenery_set = get_scenery_group_entry(i);
rct_scenery_group_entry * scenery_set = get_scenery_group_entry(i);
if (scenery_set == nullptr)
{
continue;
@ -664,8 +664,8 @@ void research_populate_list_random()
// Scenery
for (sint32 i = 0; i < MAX_SCENERY_GROUP_OBJECTS; i++)
{
rct_scenery_set_entry * scenerySetEntry = get_scenery_group_entry(i);
if (scenerySetEntry == nullptr)
rct_scenery_group_entry * sceneryGroupEntry = get_scenery_group_entry(i);
if (sceneryGroupEntry == nullptr)
{
continue;
}
@ -699,8 +699,8 @@ void research_populate_list_researched()
// Scenery
for (sint32 i = 0; i < MAX_SCENERY_GROUP_OBJECTS; i++)
{
rct_scenery_set_entry * scenerySetEntry = get_scenery_group_entry(i);
if (scenerySetEntry == nullptr)
rct_scenery_group_entry * sceneryGroupEntry = get_scenery_group_entry(i);
if (sceneryGroupEntry == nullptr)
{
continue;
}
@ -891,7 +891,7 @@ rct_string_id research_item_get_name(uint32 researchItem)
}
else
{
rct_scenery_set_entry * sceneryEntry = get_scenery_group_entry(researchItem & 0xFF);
rct_scenery_group_entry * sceneryEntry = get_scenery_group_entry(researchItem & 0xFF);
if (sceneryEntry == nullptr)
{
return 0;

2
src/openrct2/object.h
View File

@ -29,7 +29,7 @@ typedef enum
OBJECT_TYPE_BANNERS,
OBJECT_TYPE_PATHS,
OBJECT_TYPE_PATH_BITS,
OBJECT_TYPE_SCENERY_SETS,
OBJECT_TYPE_SCENERY_GROUP,
OBJECT_TYPE_PARK_ENTRANCE,
OBJECT_TYPE_WATER,
OBJECT_TYPE_SCENARIO_TEXT

2
src/openrct2/object/ObjectFactory.cpp
View File

@ -186,7 +186,7 @@ namespace ObjectFactory
case OBJECT_TYPE_PATH_BITS:
result = new FootpathItemObject(entry);
break;
case OBJECT_TYPE_SCENERY_SETS:
case OBJECT_TYPE_SCENERY_GROUP:
result = new SceneryGroupObject(entry);
break;
case OBJECT_TYPE_PARK_ENTRANCE:

2
src/openrct2/object/ObjectManager.cpp
View File

@ -424,7 +424,7 @@ private:
sceneryEntry = (rct_scenery_entry *)loadedObject->GetLegacyData();
sceneryEntry->path_bit.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject);
break;
case OBJECT_TYPE_SCENERY_SETS:
case OBJECT_TYPE_SCENERY_GROUP:
auto sgObject = dynamic_cast<SceneryGroupObject *>(loadedObject);
sgObject->UpdateEntryIndexes();
break;

6
src/openrct2/object/ObjectRepository.cpp
View File

@ -135,7 +135,7 @@ protected:
}
stream->WriteValue<uint8>(item.RideGroupIndex);
break;
case OBJECT_TYPE_SCENERY_SETS:
case OBJECT_TYPE_SCENERY_GROUP:
stream->WriteValue<uint16>(item.NumThemeObjects);
for (uint16 i = 0; i < item.NumThemeObjects; i++)
{
@ -166,7 +166,7 @@ protected:
}
item.RideGroupIndex = stream->ReadValue<uint8>();
break;
case OBJECT_TYPE_SCENERY_SETS:
case OBJECT_TYPE_SCENERY_GROUP:
item.NumThemeObjects = stream->ReadValue<uint16>();
item.ThemeObjects = Memory::AllocateArray<rct_object_entry>(item.NumThemeObjects);
for (uint16 i = 0; i < item.NumThemeObjects; i++)
@ -436,7 +436,7 @@ private:
uint8 objectType = item->ObjectEntry.flags & 0x0F;
switch (objectType) {
case OBJECT_TYPE_SCENERY_SETS:
case OBJECT_TYPE_SCENERY_GROUP:
Memory::Free(item->ThemeObjects);
item->ThemeObjects = nullptr;
break;

2
src/openrct2/object/SceneryGroupObject.h
View File

@ -27,7 +27,7 @@ struct ObjectRepositoryItem;
class SceneryGroupObject final : public Object
{
private:
rct_scenery_set_entry _legacyType = { 0 };
rct_scenery_group_entry _legacyType = { 0 };
uint32 _numItems = 0;
rct_object_entry * _items = nullptr;

2
src/openrct2/object_list.c
View File

@ -59,7 +59,7 @@ sint32 object_entry_group_encoding[] = {
rct_banner *gBannerSceneryEntries[MAX_BANNER_OBJECTS];
rct_footpath_entry *gFootpathEntries[MAX_PATH_OBJECTS];
rct_path_bit_scenery_entry *gFootpathAdditionEntries[MAX_PATH_ADDITION_OBJECTS];
rct_scenery_set_entry *gSceneryGroupEntries[MAX_SCENERY_GROUP_OBJECTS];
rct_scenery_group_entry *gSceneryGroupEntries[MAX_SCENERY_GROUP_OBJECTS];
rct_entrance_type *gParkEntranceEntries[MAX_PARK_ENTRANCE_OBJECTS];
rct_water_type *gWaterEntries[MAX_WATER_OBJECTS];
rct_stex_entry *gStexEntries[MAX_SCENARIO_TEXT_OBJECTS];

4
src/openrct2/object_list.h
View File

@ -32,7 +32,7 @@ extern "C" {
extern rct_banner *gBannerSceneryEntries[MAX_BANNER_OBJECTS];
extern rct_footpath_entry *gFootpathEntries[MAX_PATH_OBJECTS];
extern rct_path_bit_scenery_entry *gFootpathAdditionEntries[MAX_PATH_ADDITION_OBJECTS];
extern rct_scenery_set_entry *gSceneryGroupEntries[MAX_SCENERY_GROUP_OBJECTS];
extern rct_scenery_group_entry *gSceneryGroupEntries[MAX_SCENERY_GROUP_OBJECTS];
extern rct_entrance_type *gParkEntranceEntries[MAX_PARK_ENTRANCE_OBJECTS];
extern rct_water_type *gWaterEntries[MAX_WATER_OBJECTS];
extern rct_stex_entry *gStexEntries[MAX_SCENARIO_TEXT_OBJECTS];
@ -46,7 +46,7 @@ extern "C" {
#define gBannerSceneryEntries RCT2_ADDRESS(RCT2_ADDRESS_BANNER_SCENERY_ENTRIES, rct_banner*)
#define gFootpathEntries RCT2_ADDRESS(RCT2_ADDRESS_PATH_TYPES, rct_footpath_entry*)
#define gFootpathAdditionEntries RCT2_ADDRESS(RCT2_ADDRESS_PATH_BIT_SCENERY_ENTRIES, rct_path_bit_scenery_entry*)
#define gSceneryGroupEntries RCT2_ADDRESS(RCT2_ADDRESS_SCENERY_SET_ENTRIES, rct_scenery_set_entry*)
#define gSceneryGroupEntries RCT2_ADDRESS(RCT2_ADDRESS_SCENERY_SET_ENTRIES, rct_scenery_group_entry*)
#define gParkEntranceEntries RCT2_ADDRESS(RCT2_ADDRESS_PARK_ENTRANCE_ENTRIES, rct_entrance_type*)
#define gWaterEntries RCT2_ADDRESS(RCT2_ADDRESS_WATER_ENTRIES, rct_water_type*)
#define gStexEntries RCT2_ADDRESS(RCT2_ADDRESS_SCENARIO_TEXT_ENTRIES, rct_stex_entry*)

66
src/openrct2/paint/tile_element/scenery_multiple.c → src/openrct2/paint/tile_element/large_scenery.c
View File

@ -26,7 +26,7 @@
#include "../../world/scenery.h"
// 6B8172:
static void scenery_multiple_paint_supports(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement, uint32 dword_F4387C, rct_large_scenery_tile *tile)
static void large_scenery_paint_supports(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement, uint32 dword_F4387C, rct_large_scenery_tile *tile)
{
if (tile->var_7 & 0x20) {
return;
@ -59,7 +59,7 @@ static void scenery_multiple_paint_supports(paint_session * session, uint8 direc
paint_util_set_general_support_height(session, clearanceHeight, 0x20);
}
static rct_large_scenery_text_glyph *scenery_multiple_sign_get_glyph(rct_large_scenery_text *text, uint32 codepoint)
static rct_large_scenery_text_glyph *large_scenery_sign_get_glyph(rct_large_scenery_text *text, uint32 codepoint)
{
if (codepoint >= countof(text->glyphs)) {
return &text->glyphs['?'];
@ -67,27 +67,27 @@ static rct_large_scenery_text_glyph *scenery_multiple_sign_get_glyph(rct_large_s
return &text->glyphs[codepoint];
}
static sint32 scenery_multiple_sign_text_width(const utf8 *str, rct_large_scenery_text *text)
static sint32 large_scenery_sign_text_width(const utf8 *str, rct_large_scenery_text *text)
{
sint32 width = 0;
uint32 codepoint;
while ((codepoint = utf8_get_next(str, &str)) != 0) {
width += scenery_multiple_sign_get_glyph(text, codepoint)->width;
width += large_scenery_sign_get_glyph(text, codepoint)->width;
}
return width;
}
static sint32 scenery_multiple_sign_text_height(const utf8 *str, rct_large_scenery_text *text)
static sint32 large_scenery_sign_text_height(const utf8 *str, rct_large_scenery_text *text)
{
sint32 height = 0;
uint32 codepoint;
while ((codepoint = utf8_get_next(str, &str)) != 0) {
height += scenery_multiple_sign_get_glyph(text, codepoint)->height;
height += large_scenery_sign_get_glyph(text, codepoint)->height;
}
return height;
}
static const utf8 *scenery_multiple_sign_fit_text(const utf8 *str, rct_large_scenery_text *text, bool height)
static const utf8 *large_scenery_sign_fit_text(const utf8 *str, rct_large_scenery_text *text, bool height)
{
static utf8 fitStr[32];
utf8 *fitStrEnd = fitStr;
@ -96,9 +96,9 @@ static const utf8 *scenery_multiple_sign_fit_text(const utf8 *str, rct_large_sce
uint32 codepoint;
while (w <= text->max_width && (codepoint = utf8_get_next(fitStrEnd, (const utf8**)&fitStrEnd)) != 0) {
if (height) {
w += scenery_multiple_sign_get_glyph(text, codepoint)->height;
w += large_scenery_sign_get_glyph(text, codepoint)->height;
} else {
w += scenery_multiple_sign_get_glyph(text, codepoint)->width;
w += large_scenery_sign_get_glyph(text, codepoint)->width;
}
}
*fitStrEnd = 0;
@ -109,10 +109,10 @@ static sint32 div_to_minus_infinity(sint32 a, sint32 b) {
return (a / b) - (a % b < 0);
}
static void scenery_multiple_sign_paint_line(paint_session * session, const utf8 *str, rct_large_scenery_text *text, sint32 textImage, sint32 textColour, uint8 direction, sint32 y_offset)
static void large_scenery_sign_paint_line(paint_session * session, const utf8 *str, rct_large_scenery_text *text, sint32 textImage, sint32 textColour, uint8 direction, sint32 y_offset)
{
const utf8 *fitStr = scenery_multiple_sign_fit_text(str, text, false);
sint32 width = scenery_multiple_sign_text_width(fitStr, text);
const utf8 *fitStr = large_scenery_sign_fit_text(str, text, false);
sint32 width = large_scenery_sign_text_width(fitStr, text);
sint32 x_offset = text->offset[(direction & 1)].x;
sint32 acc = y_offset * ((direction & 1) ? -1 : 1);
if (!(text->flags & LARGE_SCENERY_TEXT_FLAG_VERTICAL)) {
@ -122,7 +122,7 @@ static void scenery_multiple_sign_paint_line(paint_session * session, const utf8
}
uint32 codepoint;
while ((codepoint = utf8_get_next(fitStr, &fitStr)) != 0) {
sint32 glyph_offset = scenery_multiple_sign_get_glyph(text, codepoint)->image_offset;
sint32 glyph_offset = large_scenery_sign_get_glyph(text, codepoint)->image_offset;
uint8 glyph_type = direction & 1;
if (text->flags & LARGE_SCENERY_TEXT_FLAG_VERTICAL) { // vertical sign
glyph_offset *= 2;
@ -149,8 +149,8 @@ static void scenery_multiple_sign_paint_line(paint_session * session, const utf8
paint_attach_to_previous_attach(session, image_id, x_offset, div_to_minus_infinity(acc, 2));
}
}
x_offset += scenery_multiple_sign_get_glyph(text, codepoint)->width;
acc += scenery_multiple_sign_get_glyph(text, codepoint)->width;
x_offset += large_scenery_sign_get_glyph(text, codepoint)->width;
acc += large_scenery_sign_get_glyph(text, codepoint)->width;
}
}
@ -183,7 +183,7 @@ static const boundbox s98E3C4[] = {
*
* rct2: 0x006B7F0C
*/
void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element * tileElement)
void large_scenery_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element * tileElement)
{
session->InteractionType = VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY;
uint32 sequenceNum = scenery_large_get_sequence(tileElement);
@ -232,20 +232,20 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
boxlength.z = ah;
sub_98197C(session, image_id, 0, 0, boxlength.x, boxlength.y, ah, height, boxoffset.x, boxoffset.y, boxoffset.z, get_current_rotation());
if (entry->large_scenery.scrolling_mode == 0xFF || direction == 1 || direction == 2) {
scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
large_scenery_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
return;
}
if (entry->large_scenery.flags & LARGE_SCENERY_FLAG_3D_TEXT) {
if (entry->large_scenery.tiles[1].x_offset != (sint16)(uint16)0xFFFF) {
sint32 sequenceDirection = (scenery_large_get_sequence(tileElement) - 1) & 3;
if (sequenceDirection != direction) {
scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
large_scenery_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
return;
}
}
rct_drawpixelinfo* dpi = session->Unk140E9A8;
if (dpi->zoom_level > 1) {
scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
large_scenery_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
return;
}
// 6B8331:
@ -274,22 +274,22 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
y_offset += 1;
utf8 fitStr[32];
const utf8 *fitStrPtr = fitStr;
safe_strcpy(fitStr, scenery_multiple_sign_fit_text(signString, text, true), sizeof(fitStr));
sint32 height2 = scenery_multiple_sign_text_height(fitStr, text);
safe_strcpy(fitStr, large_scenery_sign_fit_text(signString, text, true), sizeof(fitStr));
sint32 height2 = large_scenery_sign_text_height(fitStr, text);
uint32 codepoint;
while ((codepoint = utf8_get_next(fitStrPtr, &fitStrPtr)) != 0) {
utf8 str[5] = {0};
utf8_write_codepoint(str, codepoint);
scenery_multiple_sign_paint_line(session, str, entry->large_scenery.text, entry->large_scenery.text_image, textColour, direction, y_offset - height2);
y_offset += scenery_multiple_sign_get_glyph(text, codepoint)->height * 2;
large_scenery_sign_paint_line(session, str, entry->large_scenery.text, entry->large_scenery.text_image, textColour, direction, y_offset - height2);
y_offset += large_scenery_sign_get_glyph(text, codepoint)->height * 2;
}
} else {
y_offset -= (direction & 1);
if (text->flags & LARGE_SCENERY_TEXT_FLAG_TWO_LINE) {
// Draw two-line sign:
sint32 width = scenery_multiple_sign_text_width(signString, text);
sint32 width = large_scenery_sign_text_width(signString, text);
if (width > text->max_width) {
y_offset -= scenery_multiple_sign_get_glyph(text, 'A')->height + 1;
y_offset -= large_scenery_sign_get_glyph(text, 'A')->height + 1;
utf8 *src = signString;
for (sint32 i = 0; i < 2; i++) {
utf8 str1[64] = {0};
@ -300,7 +300,7 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
sint32 w = 0;
uint32 codepoint = utf8_get_next(src, (const utf8**)&src);
do {
w += scenery_multiple_sign_get_glyph(text, codepoint)->width;
w += large_scenery_sign_get_glyph(text, codepoint)->width;
if (codepoint == ' ') {
spacesrc = src;
spacedst = dst;
@ -311,27 +311,27 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
*spacedst = 0;
src = spacesrc;
}
scenery_multiple_sign_paint_line(session, str1, entry->large_scenery.text, entry->large_scenery.text_image, textColour, direction, y_offset);
y_offset += (scenery_multiple_sign_get_glyph(text, 'A')->height + 1) * 2;
large_scenery_sign_paint_line(session, str1, entry->large_scenery.text, entry->large_scenery.text_image, textColour, direction, y_offset);
y_offset += (large_scenery_sign_get_glyph(text, 'A')->height + 1) * 2;
}
} else {
scenery_multiple_sign_paint_line(session, signString, entry->large_scenery.text, entry->large_scenery.text_image, textColour, direction, y_offset);
large_scenery_sign_paint_line(session, signString, entry->large_scenery.text, entry->large_scenery.text_image, textColour, direction, y_offset);
}
} else {
// Draw one-line sign:
scenery_multiple_sign_paint_line(session, signString, entry->large_scenery.text, entry->large_scenery.text_image, textColour, direction, y_offset);
large_scenery_sign_paint_line(session, signString, entry->large_scenery.text, entry->large_scenery.text_image, textColour, direction, y_offset);
}
}
return;
}
rct_drawpixelinfo* dpi = session->Unk140E9A8;
if (dpi->zoom_level > 0) {
scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
large_scenery_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
return;
}
uint8 sequenceDirection2 = (scenery_large_get_sequence(tileElement) - 1) & 3;
if (sequenceDirection2 != direction) {
scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
large_scenery_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
return;
}
// Draw scrolling text:
@ -369,5 +369,5 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
uint16 scroll = (gCurrentTicks / 2) % string_width;
sub_98199C(session, scrolling_text_setup(session, stringId, scroll, scrollMode), 0, 0, 1, 1, 21, height + 25, boxoffset.x, boxoffset.y, boxoffset.z, get_current_rotation());
scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
large_scenery_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
}

6
src/openrct2/paint/tile_element/tile_element.c
View File

@ -291,7 +291,7 @@ static void sub_68B3FB(paint_session * session, sint32 x, sint32 y)
case TILE_ELEMENT_TYPE_TRACK:
track_paint(session, direction, height, tile_element);
break;
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
scenery_paint(session, direction, height, tile_element);
break;
case TILE_ELEMENT_TYPE_ENTRANCE:
@ -300,8 +300,8 @@ static void sub_68B3FB(paint_session * session, sint32 x, sint32 y)
case TILE_ELEMENT_TYPE_WALL:
fence_paint(session, direction, height, tile_element);
break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
scenery_multiple_paint(session, direction, height, tile_element);
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
large_scenery_paint(session, direction, height, tile_element);
break;
case TILE_ELEMENT_TYPE_BANNER:
banner_paint(session, direction, height, tile_element);

2
src/openrct2/paint/tile_element/tile_element.h
View File

@ -115,7 +115,7 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
void path_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement);
void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* tileElement);
void fence_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* tileElement);
void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement);
void large_scenery_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement);
void track_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *tileElement);
#ifdef __cplusplus

14
src/openrct2/peep/Peep.cpp
View File

@ -633,8 +633,8 @@ static uint8 peep_assess_surroundings(sint16 centre_x, sint16 centre_y, sint16 c
num_rubbish++;
}
break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
num_scenery++;
break;
case TILE_ELEMENT_TYPE_TRACK:
@ -5529,7 +5529,7 @@ static void peep_update_watering(rct_peep * peep)
do
{
if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SCENERY)
if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
continue;
if (abs(((sint32)peep->next_z) - tile_element->base_height) > 4)
@ -6787,7 +6787,7 @@ static sint32 peep_update_patrolling_find_watering(rct_peep * peep)
do
{
if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SCENERY)
if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
{
continue;
}
@ -12729,7 +12729,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
}
}
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
{
if (!(get_large_scenery_entry(scenery_large_get_type(tileElement))->large_scenery.flags &
LARGE_SCENERY_FLAG_PHOTOGENIC))
@ -12840,7 +12840,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
}
}
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
{
auto sceneryEntry = get_large_scenery_entry(scenery_large_get_type(tileElement));
if (!(sceneryEntry == nullptr || sceneryEntry->large_scenery.flags &
@ -12952,7 +12952,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
}
}
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
{
if (!(get_large_scenery_entry(scenery_large_get_type(tileElement))->large_scenery.flags &
LARGE_SCENERY_FLAG_PHOTOGENIC))

22
src/openrct2/rct1/S4Importer.cpp
View File

@ -469,10 +469,10 @@ private:
AddEntryForPathAddition(pathAdditionsType);
break;
}
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
AddEntryForSmallScenery(tileElement->properties.scenery.type);
break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
AddEntryForLargeScenery(scenery_large_get_type(tileElement));
break;
case TILE_ELEMENT_TYPE_WALL:
@ -1770,7 +1770,7 @@ private:
LoadObjects(OBJECT_TYPE_WALLS, _wallEntries);
LoadObjects(OBJECT_TYPE_PATHS, _pathEntries);
LoadObjects(OBJECT_TYPE_PATH_BITS, _pathAdditionEntries);
LoadObjects(OBJECT_TYPE_SCENERY_SETS, _sceneryGroupEntries);
LoadObjects(OBJECT_TYPE_SCENERY_GROUP, _sceneryGroupEntries);
LoadObjects(OBJECT_TYPE_BANNERS, std::vector<const char *>({
"BN1 ",
"BN2 ",
@ -1804,7 +1804,7 @@ private:
entry.checksum = 0;
Object * object = objectManager->LoadObject(&entry);
if (object == nullptr && objectType != OBJECT_TYPE_SCENERY_SETS)
if (object == nullptr && objectType != OBJECT_TYPE_SCENERY_GROUP)
{
log_error("Failed to load %s.", objectName);
throw Exception("Failed to load object.");
@ -1823,7 +1823,7 @@ private:
GetInvalidObjects(OBJECT_TYPE_WALLS, _wallEntries.GetEntries(), missingObjects);
GetInvalidObjects(OBJECT_TYPE_PATHS, _pathEntries.GetEntries(), missingObjects);
GetInvalidObjects(OBJECT_TYPE_PATH_BITS, _pathAdditionEntries.GetEntries(), missingObjects);
GetInvalidObjects(OBJECT_TYPE_SCENERY_SETS, _sceneryGroupEntries.GetEntries(), missingObjects);
GetInvalidObjects(OBJECT_TYPE_SCENERY_GROUP, _sceneryGroupEntries.GetEntries(), missingObjects);
GetInvalidObjects(OBJECT_TYPE_BANNERS, std::vector<const char *>({
"BN1 ",
"BN2 ",
@ -1859,7 +1859,7 @@ private:
else
{
Object * object = objectRepository->LoadObject(ori);
if (object == nullptr && objectType != OBJECT_TYPE_SCENERY_SETS)
if (object == nullptr && objectType != OBJECT_TYPE_SCENERY_GROUP)
{
missingObjects.push_back(entry);
Console::Error::WriteLine("[%s] Object could not be loaded.", objectName);
@ -2280,7 +2280,7 @@ private:
if (tileElement->base_height != 255)
{
switch (tile_element_get_type(tileElement)) {
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
colour = RCT1::GetColour(scenery_small_get_primary_colour(tileElement));
scenery_small_set_primary_colour(tileElement, colour);
@ -2305,7 +2305,7 @@ private:
tileElement->type |= (colour & 0x18) << 3;
tileElement->properties.wall.type |= (colour & 7) << 5;
break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
colour = RCT1::GetColour(scenery_large_get_primary_colour(tileElement));
scenery_large_set_primary_colour(tileElement, colour);
@ -2569,10 +2569,10 @@ private:
{
rct_tile_element * tileElement = it.element;
switch (tile_element_get_type(tileElement)) {
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
tileElement->properties.scenery.type = _smallSceneryTypeToEntryMap[tileElement->properties.scenery.type];
break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
{
uint8 type = scenery_large_get_type(tileElement);
scenery_large_set_type(tileElement, _largeSceneryTypeToEntryMap[type]);
@ -2591,7 +2591,7 @@ private:
case OBJECT_TYPE_WALLS: return &_wallEntries;
case OBJECT_TYPE_PATHS: return &_pathEntries;
case OBJECT_TYPE_PATH_BITS: return &_pathAdditionEntries;
case OBJECT_TYPE_SCENERY_SETS: return &_sceneryGroupEntries;
case OBJECT_TYPE_SCENERY_GROUP: return &_sceneryGroupEntries;
case OBJECT_TYPE_WATER: return &_waterEntry;
}
return nullptr;

2
src/openrct2/ride/TrackDesign.cpp
View File

@ -799,7 +799,7 @@ track_design_place_scenery(rct_td6_scenery_element * scenery_start, uint8 rideIn
uint8 quadrant = (scenery->flags >> 2) + _currentTrackPieceDirection;
quadrant &= 3;
uint8 bh = rotation | (quadrant << 6) | TILE_ELEMENT_TYPE_SCENERY;
uint8 bh = rotation | (quadrant << 6) | TILE_ELEMENT_TYPE_SMALL_SCENERY;
rct_scenery_entry * small_scenery = get_small_scenery_entry(entry_index);
if (!(!(small_scenery->small_scenery.flags & SMALL_SCENERY_FLAG_FULL_TILE) &&

4
src/openrct2/ride/Vehicle.cpp
View File

@ -1820,7 +1820,7 @@ static void vehicle_update_measurements(rct_vehicle * vehicle)
bool cover_found = false;
do
{
if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
{
cover_found = true;
break;
@ -1832,7 +1832,7 @@ static void vehicle_update_measurements(rct_vehicle * vehicle)
break;
}
if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SCENERY)
if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
continue;
rct_scenery_entry * scenery = get_small_scenery_entry(tile_element->properties.scenery.type);

6
src/openrct2/ride/ride_ratings.c
View File

@ -406,8 +406,8 @@ static void ride_ratings_score_close_proximity_in_direction(rct_tile_element *in
}
}
break;
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
if (tileElement->base_height < inputTileElement->clearance_height) {
if (inputTileElement->base_height > tileElement->clearance_height) {
proximity_score_increment(PROXIMITY_SCENERY_SIDE_ABOVE);
@ -1297,7 +1297,7 @@ static sint32 ride_ratings_get_scenery_score(Ride *ride)
continue;
sint32 type = tile_element_get_type(tileElement);
if (type == TILE_ELEMENT_TYPE_SCENERY || type == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
if (type == TILE_ELEMENT_TYPE_SMALL_SCENERY || type == TILE_ELEMENT_TYPE_LARGE_SCENERY)
numSceneryItems++;
} while (!tile_element_is_last_for_tile(tileElement++));
}

8
src/openrct2/ride/track_design_save.c
View File

@ -209,11 +209,11 @@ static sint32 tile_element_get_total_element_count(rct_tile_element *tileElement
switch (tile_element_get_type(tileElement)) {
case TILE_ELEMENT_TYPE_PATH:
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
case TILE_ELEMENT_TYPE_WALL:
return 1;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
sceneryEntry = get_large_scenery_entry(scenery_large_get_type(tileElement));
tile = sceneryEntry->large_scenery.tiles;
elementCount = 0;
@ -619,13 +619,13 @@ static void track_design_save_select_nearby_scenery_for_tile(sint32 rideIndex, s
else if (tileElement->properties.path.addition_status == rideIndex)
interactionType = VIEWPORT_INTERACTION_ITEM_FOOTPATH;
break;
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
interactionType = VIEWPORT_INTERACTION_ITEM_SCENERY;
break;
case TILE_ELEMENT_TYPE_WALL:
interactionType = VIEWPORT_INTERACTION_ITEM_WALL;
break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
interactionType = VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY;
break;
}

14
src/openrct2/windows/EditorObjectSelection.cpp
View File

@ -537,7 +537,7 @@ static void setup_in_use_selection_flags()
Editor::SelectedObjects[OBJECT_TYPE_PATH_BITS][path_additions] |= 1;
}
break;
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
type = iter.element->properties.scenery.type;
assert(type < object_entry_group_counts[OBJECT_TYPE_SMALL_SCENERY]);
Editor::SelectedObjects[OBJECT_TYPE_SMALL_SCENERY][type] |= (1 << 0);
@ -557,7 +557,7 @@ static void setup_in_use_selection_flags()
assert(type < object_entry_group_counts[OBJECT_TYPE_WALLS]);
Editor::SelectedObjects[OBJECT_TYPE_WALLS][type] |= (1 << 0);
break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
type = scenery_large_get_type(iter.element);
assert(type < object_entry_group_counts[OBJECT_TYPE_LARGE_SCENERY]);
Editor::SelectedObjects[OBJECT_TYPE_LARGE_SCENERY][type] |= (1 << 0);
@ -673,7 +673,7 @@ static void remove_selected_objects_from_research(const rct_object_entry* instal
research_remove(entry_index | rideEntry->ride_type[j] << 8 | 0x10000);
}
}
else if (entry_type == OBJECT_TYPE_SCENERY_SETS){
else if (entry_type == OBJECT_TYPE_SCENERY_GROUP){
research_remove(entry_index);
}
}
@ -1571,7 +1571,7 @@ static sint32 window_editor_object_selection_select_object(uint8 bh, sint32 flag
}
uint8 objectType = item->ObjectEntry.flags & 0xF;
if (objectType == OBJECT_TYPE_SCENERY_SETS && (flags & (1 << 2))) {
if (objectType == OBJECT_TYPE_SCENERY_GROUP && (flags & (1 << 2))) {
for (sint32 j = 0; j < item->NumThemeObjects; j++) {
window_editor_object_selection_select_object(++bh, flags, &item->ThemeObjects[j]);
}
@ -1601,7 +1601,7 @@ static sint32 window_editor_object_selection_select_object(uint8 bh, sint32 flag
return 0;
}
if (objectType == OBJECT_TYPE_SCENERY_SETS && (flags & (1 << 2))) {
if (objectType == OBJECT_TYPE_SCENERY_GROUP && (flags & (1 << 2))) {
for (uint16 j = 0; j < item->NumThemeObjects; j++) {
if (!window_editor_object_selection_select_object(++bh, flags, &item->ThemeObjects[j])) {
_maxObjectsWasHit = true;
@ -1695,7 +1695,7 @@ static void editor_load_selected_objects()
uint8 rideType = ride_entry_get_first_non_null_ride_type(rideEntry);
research_insert(1, 0x10000 | (rideType << 8) | entryIndex, rideEntry->category[0]);
}
else if (objectType == OBJECT_TYPE_SCENERY_SETS) {
else if (objectType == OBJECT_TYPE_SCENERY_GROUP) {
research_insert(1, entryIndex, RESEARCH_CATEGORY_SCENERYSET);
}
}
@ -1909,7 +1909,7 @@ sint32 editor_remove_unused_objects()
const ObjectRepositoryItem * item = &items[i];
uint8 objectType = item->ObjectEntry.flags & 0xF;
if (objectType == OBJECT_TYPE_PARK_ENTRANCE || objectType == OBJECT_TYPE_SCENARIO_TEXT || objectType == OBJECT_TYPE_WATER || objectType == OBJECT_TYPE_SCENERY_SETS)
if (objectType == OBJECT_TYPE_PARK_ENTRANCE || objectType == OBJECT_TYPE_SCENARIO_TEXT || objectType == OBJECT_TYPE_WATER || objectType == OBJECT_TYPE_SCENERY_GROUP)
{
continue;
}

4
src/openrct2/windows/TileInspector.cpp
View File

@ -1989,7 +1989,7 @@ static void window_tile_inspector_scrollpaint(rct_window *w, rct_drawpixelinfo *
case TILE_ELEMENT_TYPE_TRACK:
typeName = "Track";
break;
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
snprintf(
buffer, sizeof(buffer),
"Scenery (%s)",
@ -2008,7 +2008,7 @@ static void window_tile_inspector_scrollpaint(rct_window *w, rct_drawpixelinfo *
);
typeName = buffer;
break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
typeName = "Scenery multiple";
break;
case TILE_ELEMENT_TYPE_BANNER:

2
src/openrct2/world/MapGen.cpp
View File

@ -247,7 +247,7 @@ static void mapgen_place_tree(sint32 type, sint32 x, sint32 y)
assert(tileElement != nullptr);
tileElement->clearance_height = surfaceZ + (sceneryEntry->small_scenery.height >> 3);
tileElement->type = TILE_ELEMENT_TYPE_SCENERY | (util_rand() & 3);
tileElement->type = TILE_ELEMENT_TYPE_SMALL_SCENERY | (util_rand() & 3);
tileElement->properties.scenery.type = type;
tileElement->properties.scenery.age = 0;
scenery_small_set_primary_colour(tileElement, COLOUR_YELLOW);

8
src/openrct2/world/SmallScenery.cpp
View File

@ -77,7 +77,7 @@ static money32 SmallSceneryRemove(sint16 x, sint16 y, uint8 baseHeight, uint8 qu
bool sceneryFound = false;
rct_tile_element* tileElement = map_get_first_element_at(x / 32, y / 32);
do {
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
continue;
if ((tileElement->type >> 6) != quadrant)
continue;
@ -409,7 +409,7 @@ static money32 SmallSceneryPlace(sint16 x,
assert(newElement != nullptr);
gSceneryTileElement = newElement;
uint8 type = quadrant << 6;
type |= TILE_ELEMENT_TYPE_SCENERY;
type |= TILE_ELEMENT_TYPE_SMALL_SCENERY;
type |= rotation;
newElement->type = type;
newElement->properties.scenery.type = sceneryType;
@ -479,7 +479,7 @@ extern "C"
*/
sint32 map_place_scenery_clear_func(rct_tile_element** tile_element, sint32 x, sint32 y, uint8 flags, money32* price)
{
if (tile_element_get_type(*tile_element) != TILE_ELEMENT_TYPE_SCENERY)
if (tile_element_get_type(*tile_element) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
return 1;
if (!(flags & GAME_COMMAND_FLAG_PATH_SCENERY))
@ -516,7 +516,7 @@ extern "C"
*/
sint32 map_place_non_scenery_clear_func(rct_tile_element** tile_element, sint32 x, sint32 y, uint8 flags, money32* price)
{
if (tile_element_get_type(*tile_element) != TILE_ELEMENT_TYPE_SCENERY)
if (tile_element_get_type(*tile_element) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
return 1;
rct_scenery_entry* scenery = get_small_scenery_entry((*tile_element)->properties.scenery.type);

4
src/openrct2/world/Wall.cpp
View File

@ -209,7 +209,7 @@ static bool WallCheckObstruction(rct_scenery_entry * wall,
return false;
}
break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
entryType = scenery_large_get_type(tileElement);
sequence = scenery_large_get_sequence(tileElement);
entry = get_large_scenery_entry(entryType);
@ -223,7 +223,7 @@ static bool WallCheckObstruction(rct_scenery_entry * wall,
}
}
break;
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
entryType = tileElement->properties.scenery.type;
entry = get_small_scenery_entry(entryType);
if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_ALLOW_WALLS)

34
src/openrct2/world/map.c
View File

@ -895,7 +895,7 @@ void game_command_remove_large_scenery(sint32* eax, sint32* ebx, sint32* ecx, si
return;
}
do {
if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_LARGE_SCENERY)
continue;
if (tile_element->base_height != base_height)
@ -972,7 +972,7 @@ void game_command_remove_large_scenery(sint32* eax, sint32* ebx, sint32* ecx, si
element_found = false;
do
{
if (tile_element_get_type(sceneryElement) != TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
if (tile_element_get_type(sceneryElement) != TILE_ELEMENT_TYPE_LARGE_SCENERY)
continue;
if (tile_element_get_direction(sceneryElement) != tile_element_direction)
@ -1134,7 +1134,7 @@ restart_from_beginning:
if (flags & 1)
goto restart_from_beginning;
} break;
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
if (clear & (1 << 0)) {
sint32 eax = x * 32;
sint32 ebx = (tileElement->type << 8) | flags;
@ -1168,7 +1168,7 @@ restart_from_beginning:
goto restart_from_beginning;
} break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
if (clear & (1 << 1)) {
sint32 eax = x * 32;
sint32 ebx = flags | ((tile_element_get_direction(tileElement)) << 8);
@ -1202,7 +1202,7 @@ static void map_reset_clear_large_scenery_flag(){
for (sint32 x = 0; x < MAXIMUM_MAP_SIZE_TECHNICAL; x++) {
tileElement = map_get_first_element_at(x, y);
do {
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE) {
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_LARGE_SCENERY) {
tileElement->flags &= ~(1 << 6);
}
} while (!tile_element_is_last_for_tile(tileElement++));
@ -1448,7 +1448,7 @@ static sint32 map_set_land_height_clear_func(rct_tile_element** tile_element, si
if (tile_element_get_type(*tile_element) == TILE_ELEMENT_TYPE_SURFACE)
return 0;
if (tile_element_get_type(*tile_element) == TILE_ELEMENT_TYPE_SCENERY)
if (tile_element_get_type(*tile_element) == TILE_ELEMENT_TYPE_SMALL_SCENERY)
return 0;
return 1;
@ -1558,7 +1558,7 @@ static money32 map_set_land_height(sint32 flags, sint32 x, sint32 y, sint32 heig
//Check for obstructing scenery
tileElement = map_get_first_element_at(x / 32, y / 32);
do {
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
continue;
if (height > tileElement->clearance_height)
continue;
@ -1643,7 +1643,7 @@ static money32 map_set_land_height(sint32 flags, sint32 x, sint32 y, sint32 heig
if (elementType == TILE_ELEMENT_TYPE_WALL)
continue;
if (elementType == TILE_ELEMENT_TYPE_SCENERY)
if (elementType == TILE_ELEMENT_TYPE_SMALL_SCENERY)
continue;
if (tileElement->flags & 0x10)
continue;
@ -2841,7 +2841,7 @@ void game_command_place_large_scenery(sint32* eax, sint32* ebx, sint32* ecx, sin
map_animation_create(MAP_ANIMATION_TYPE_LARGE_SCENERY, curTile.x, curTile.y, zLow);
new_tile_element->clearance_height = zHigh;
new_tile_element->type = TILE_ELEMENT_TYPE_SCENERY_MULTIPLE | rotation;
new_tile_element->type = TILE_ELEMENT_TYPE_LARGE_SCENERY | rotation;
scenery_large_set_type(new_tile_element, entry_index);
scenery_large_set_sequence(new_tile_element, tile_num);
@ -3178,7 +3178,7 @@ void map_obstruction_set_error_text(rct_tile_element *tileElement)
set_format_arg(0, rct_string_id, ride->name);
set_format_arg(2, uint32, ride->name_arguments);
break;
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
sceneryEntry = get_small_scenery_entry(tileElement->properties.scenery.type);
errorStringId = STR_X_IN_THE_WAY;
set_format_arg(0, rct_string_id, sceneryEntry->name);
@ -3201,7 +3201,7 @@ void map_obstruction_set_error_text(rct_tile_element *tileElement)
errorStringId = STR_X_IN_THE_WAY;
set_format_arg(0, rct_string_id, sceneryEntry->name);
break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
sceneryEntry = get_large_scenery_entry(tileElement->properties.scenery.type);
errorStringId = STR_X_IN_THE_WAY;
set_format_arg(0, rct_string_id, sceneryEntry->name);
@ -3481,7 +3481,7 @@ sint32 tile_element_get_banner_index(rct_tile_element *tileElement)
rct_scenery_entry* sceneryEntry;
switch (tile_element_get_type(tileElement)) {
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
sceneryEntry = get_large_scenery_entry(scenery_large_get_type(tileElement));
if (sceneryEntry->large_scenery.scrolling_mode == 0xFF)
return -1;
@ -3648,7 +3648,7 @@ static void clear_element_at(sint32 x, sint32 y, rct_tile_element **elementPtr)
0
);
break;
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
gGameCommandErrorTitle = STR_CANT_REMOVE_THIS;
game_do_command(
x,
@ -3741,7 +3741,7 @@ rct_tile_element *map_get_large_scenery_segment(sint32 x, sint32 y, sint32 z, si
return NULL;
}
do {
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_LARGE_SCENERY)
continue;
if (tileElement->base_height != z)
continue;
@ -3840,7 +3840,7 @@ rct_tile_element *map_get_small_scenery_element_at(sint32 x, sint32 y, sint32 z,
{
do
{
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
continue;
if (tileElement->type >> 6 != quadrant)
continue;
@ -4098,7 +4098,7 @@ bool map_surface_is_blocked(sint16 x, sint16 y){
tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL)
continue;
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
return true;
rct_scenery_entry* scenery = get_small_scenery_entry(tileElement->properties.scenery.type);
@ -4237,7 +4237,7 @@ void game_command_set_sign_style(sint32* eax, sint32* ebx, sint32* ecx, sint32*
map_invalidate_tile(x, y, tile_element->base_height * 8, tile_element->clearance_height * 8);
} else { // large sign
rct_tile_element *tileElement = banner_get_tile_element(bannerId);
if (tileElement == NULL || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY_MULTIPLE) {
if (tileElement == NULL || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_LARGE_SCENERY) {
gGameCommandErrorText = STR_ERR_CANT_SET_BANNER_TEXT;
*ebx = MONEY32_UNDEFINED;
return;

4
src/openrct2/world/map.h
View File

@ -142,10 +142,10 @@ enum {
TILE_ELEMENT_TYPE_SURFACE = (0 << 2),
TILE_ELEMENT_TYPE_PATH = (1 << 2),
TILE_ELEMENT_TYPE_TRACK = (2 << 2),
TILE_ELEMENT_TYPE_SCENERY = (3 << 2),
TILE_ELEMENT_TYPE_SMALL_SCENERY = (3 << 2),
TILE_ELEMENT_TYPE_ENTRANCE = (4 << 2),
TILE_ELEMENT_TYPE_WALL = (5 << 2),
TILE_ELEMENT_TYPE_SCENERY_MULTIPLE = (6 << 2),
TILE_ELEMENT_TYPE_LARGE_SCENERY = (6 << 2),
TILE_ELEMENT_TYPE_BANNER = (7 << 2),
// The corrupt element type is used for skipping drawing other following
// elements on a given tile.

4
src/openrct2/world/map_animation.c
View File

@ -178,7 +178,7 @@ static bool map_animation_invalidate_small_scenery(sint32 x, sint32 y, sint32 ba
do {
if (tileElement->base_height != baseZ)
continue;
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
continue;
if (tileElement->flags & (1 << 4))
continue;
@ -433,7 +433,7 @@ static bool map_animation_invalidate_large_scenery(sint32 x, sint32 y, sint32 ba
do {
if (tileElement->base_height != baseZ)
continue;
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_LARGE_SCENERY)
continue;
sceneryEntry = get_large_scenery_entry(tileElement->properties.scenery.type & 0x3FF);

12
src/openrct2/world/scenery.c
View File

@ -89,7 +89,7 @@ void scenery_update_tile(sint32 x, sint32 y)
continue;
}
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SCENERY) {
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SMALL_SCENERY) {
scenery_update_age(x, y, tileElement);
} else if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH) {
if (footpath_element_has_path_scenery(tileElement) && !footpath_element_path_scenery_is_ghost(tileElement)) {
@ -148,13 +148,13 @@ void scenery_update_age(sint32 x, sint32 y, rct_tile_element *tileElement)
continue;
switch (tile_element_get_type(tileElementAbove)) {
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
case TILE_ELEMENT_TYPE_LARGE_SCENERY:
case TILE_ELEMENT_TYPE_ENTRANCE:
case TILE_ELEMENT_TYPE_PATH:
map_invalidate_tile_zoom1(x, y, tileElementAbove->base_height * 8, tileElementAbove->clearance_height * 8);
scenery_increase_age(x, y, tileElement);
return;
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
sceneryEntry = get_small_scenery_entry(tileElementAbove->properties.scenery.type);
if (sceneryEntry->small_scenery.flags & SMALL_SCENERY_FLAG_VOFFSET_CENTRE) {
scenery_increase_age(x, y, tileElement);
@ -305,12 +305,12 @@ rct_scenery_entry *get_footpath_item_entry(sint32 entryIndex)
return (rct_scenery_entry*)gFootpathAdditionEntries[entryIndex];
}
rct_scenery_set_entry *get_scenery_group_entry(sint32 entryIndex)
rct_scenery_group_entry *get_scenery_group_entry(sint32 entryIndex)
{
if (entryIndex >= object_entry_group_counts[OBJECT_TYPE_SCENERY_SETS]) {
if (entryIndex >= object_entry_group_counts[OBJECT_TYPE_SCENERY_GROUP]) {
return NULL;
}
return (rct_scenery_set_entry*)gSceneryGroupEntries[entryIndex];
return (rct_scenery_group_entry*)gSceneryGroupEntries[entryIndex];
}
sint32 get_scenery_id_from_entry_index(uint8 objectType, sint32 entryIndex)

8
src/openrct2/world/scenery.h
View File

@ -196,7 +196,7 @@ typedef struct rct_scenery_entry {
assert_struct_size(rct_scenery_entry, 6 + 21);
#endif
typedef struct rct_scenery_set_entry {
typedef struct rct_scenery_group_entry {
rct_string_id name; // 0x00
uint32 image; // 0x02
uint16 scenery_entries[0x80]; // 0x06
@ -205,8 +205,8 @@ typedef struct rct_scenery_set_entry {
uint8 var_108; // 0x108, order?
uint8 pad_109;
uint32 entertainer_costumes; // 0x10A
} rct_scenery_set_entry;
assert_struct_size(rct_scenery_set_entry, 14 + 2 * 0x80);
} rct_scenery_group_entry;
assert_struct_size(rct_scenery_group_entry, 14 + 2 * 0x80);
#pragma pack(pop)
enum {
@ -308,7 +308,7 @@ rct_scenery_entry *get_large_scenery_entry(sint32 entryIndex);
rct_scenery_entry *get_wall_entry(sint32 entryIndex);
rct_scenery_entry *get_banner_entry(sint32 entryIndex);
rct_scenery_entry *get_footpath_item_entry(sint32 entryIndex);
rct_scenery_set_entry *get_scenery_group_entry(sint32 entryIndex);
rct_scenery_group_entry *get_scenery_group_entry(sint32 entryIndex);
sint32 get_scenery_id_from_entry_index(uint8 objectType, sint32 entryIndex);

6
src/openrct2/world/tile_inspector.c
View File

@ -223,7 +223,7 @@ sint32 tile_inspector_rotate_element_at(sint32 x, sint32 y, sint32 elementIndex,
tileElement->properties.path.edges |= ((pathCorners << 1) | (pathCorners >> 3)) & 0xF0;
break;
case TILE_ELEMENT_TYPE_TRACK:
case TILE_ELEMENT_TYPE_SCENERY:
case TILE_ELEMENT_TYPE_SMALL_SCENERY:
case TILE_ELEMENT_TYPE_ENTRANCE:
case TILE_ELEMENT_TYPE_WALL:
newRotation = tile_element_get_direction_with_offset(tileElement, 1);
@ -840,7 +840,7 @@ sint32 tile_inspector_scenery_set_quarter_location(sint32 x, sint32 y, sint32 el
{
rct_tile_element *const tileElement = map_get_nth_element_at(x, y, elementIndex);
if (!tileElement || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
if (!tileElement || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
{
return MONEY32_UNDEFINED;
}
@ -869,7 +869,7 @@ sint32 tile_inspector_scenery_set_quarter_collision(sint32 x, sint32 y, sint32 e
{
rct_tile_element *const tileElement = map_get_nth_element_at(x, y, elementIndex);
if (!tileElement || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
if (!tileElement || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
{
return MONEY32_UNDEFINED;
}

2
test/testpaint/compat.c
View File

@ -87,7 +87,7 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
void path_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement) { }
void scenery_paint(paint_session * session, uint8 direction, int height, rct_tile_element *tileElement) { }
void fence_paint(paint_session * session, uint8 direction, int height, rct_tile_element *tileElement) { }
void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement) { }
void large_scenery_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement) { }
Ride *get_ride(int index) {
if (index < 0 || index >= MAX_RIDES) {