mirror of https://github.com/OpenRCT2/OpenRCT2.git
Replace mapElement with tileElement
This commit is contained in:
parent
ce8d9cc71b
commit
af845beb61
|
@ -795,10 +795,10 @@ static void window_footpath_set_provisional_path_at_point(sint32 x, sint32 y)
|
|||
gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
|
||||
|
||||
sint32 interactionType;
|
||||
rct_tile_element * mapElement;
|
||||
rct_tile_element * tileElement;
|
||||
LocationXY16 mapCoord = {0};
|
||||
get_map_coordinates_from_pos(x, y, VIEWPORT_INTERACTION_MASK_FOOTPATH & VIEWPORT_INTERACTION_MASK_TERRAIN,
|
||||
&mapCoord.x, &mapCoord.y, &interactionType, &mapElement, nullptr);
|
||||
&mapCoord.x, &mapCoord.y, &interactionType, &tileElement, nullptr);
|
||||
x = mapCoord.x;
|
||||
y = mapCoord.y;
|
||||
|
||||
|
@ -814,7 +814,7 @@ static void window_footpath_set_provisional_path_at_point(sint32 x, sint32 y)
|
|||
(gFootpathProvisionalFlags & PROVISIONAL_PATH_FLAG_1) &&
|
||||
gFootpathProvisionalPosition.x == x &&
|
||||
gFootpathProvisionalPosition.y == y &&
|
||||
gFootpathProvisionalPosition.z == mapElement->base_height
|
||||
gFootpathProvisionalPosition.z == tileElement->base_height
|
||||
)
|
||||
{
|
||||
return;
|
||||
|
@ -831,14 +831,14 @@ static void window_footpath_set_provisional_path_at_point(sint32 x, sint32 y)
|
|||
footpath_provisional_update();
|
||||
|
||||
// Set provisional path
|
||||
sint32 slope = default_path_slope[mapElement->properties.surface.slope & 0x1F];
|
||||
sint32 slope = default_path_slope[tileElement->properties.surface.slope & 0x1F];
|
||||
if (interactionType == VIEWPORT_INTERACTION_ITEM_FOOTPATH)
|
||||
{
|
||||
slope = mapElement->properties.surface.slope & 7;
|
||||
slope = tileElement->properties.surface.slope & 7;
|
||||
}
|
||||
sint32 pathType = (gFootpathSelectedType << 7) + (gFootpathSelectedId & 0xFF);
|
||||
|
||||
_window_footpath_cost = footpath_provisional_set(pathType, x, y, mapElement->base_height, slope);
|
||||
_window_footpath_cost = footpath_provisional_set(pathType, x, y, tileElement->base_height, slope);
|
||||
window_invalidate_by_class(WC_FOOTPATH);
|
||||
}
|
||||
}
|
||||
|
@ -850,13 +850,13 @@ static void window_footpath_set_provisional_path_at_point(sint32 x, sint32 y)
|
|||
static void window_footpath_set_selection_start_bridge_at_point(sint32 screenX, sint32 screenY)
|
||||
{
|
||||
sint32 x, y, direction;
|
||||
rct_tile_element * mapElement;
|
||||
rct_tile_element * tileElement;
|
||||
|
||||
map_invalidate_selection_rect();
|
||||
gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE;
|
||||
gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
|
||||
|
||||
footpath_bridge_get_info_from_pos(screenX, screenY, &x, &y, &direction, &mapElement);
|
||||
footpath_bridge_get_info_from_pos(screenX, screenY, &x, &y, &direction, &tileElement);
|
||||
if (x == LOCATION_NULL)
|
||||
{
|
||||
return;
|
||||
|
@ -874,11 +874,11 @@ static void window_footpath_set_selection_start_bridge_at_point(sint32 screenX,
|
|||
gMapSelectArrowPosition.x = x;
|
||||
gMapSelectArrowPosition.y = y;
|
||||
|
||||
sint32 z = mapElement->base_height;
|
||||
sint32 z = tileElement->base_height;
|
||||
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SURFACE)
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
|
||||
{
|
||||
uint8 slope = mapElement->properties.surface.slope;
|
||||
uint8 slope = tileElement->properties.surface.slope;
|
||||
if (slope & 0xf)
|
||||
{
|
||||
z += 2;
|
||||
|
@ -899,7 +899,7 @@ static void window_footpath_set_selection_start_bridge_at_point(sint32 screenX,
|
|||
static void window_footpath_place_path_at_point(sint32 x, sint32 y)
|
||||
{
|
||||
sint32 interactionType, presentType, selectedType, z, cost;
|
||||
rct_tile_element * mapElement;
|
||||
rct_tile_element * tileElement;
|
||||
|
||||
if (_footpathErrorOccured)
|
||||
{
|
||||
|
@ -910,7 +910,7 @@ static void window_footpath_place_path_at_point(sint32 x, sint32 y)
|
|||
|
||||
LocationXY16 mapCoord = {0};
|
||||
get_map_coordinates_from_pos(x, y, VIEWPORT_INTERACTION_MASK_FOOTPATH & VIEWPORT_INTERACTION_MASK_TERRAIN,
|
||||
&mapCoord.x, &mapCoord.y, &interactionType, &mapElement, nullptr);
|
||||
&mapCoord.x, &mapCoord.y, &interactionType, &tileElement, nullptr);
|
||||
x = mapCoord.x;
|
||||
y = mapCoord.y;
|
||||
|
||||
|
@ -920,12 +920,12 @@ static void window_footpath_place_path_at_point(sint32 x, sint32 y)
|
|||
}
|
||||
|
||||
// Set path
|
||||
presentType = default_path_slope[mapElement->properties.path.type & 0x1F];
|
||||
presentType = default_path_slope[tileElement->properties.path.type & 0x1F];
|
||||
if (interactionType == VIEWPORT_INTERACTION_ITEM_FOOTPATH)
|
||||
{
|
||||
presentType = mapElement->properties.path.type & 7;
|
||||
presentType = tileElement->properties.path.type & 7;
|
||||
}
|
||||
z = mapElement->base_height;
|
||||
z = tileElement->base_height;
|
||||
selectedType = (gFootpathSelectedType << 7) + (gFootpathSelectedId & 0xFF);
|
||||
|
||||
// Try and place path
|
||||
|
@ -952,20 +952,20 @@ static void window_footpath_place_path_at_point(sint32 x, sint32 y)
|
|||
static void window_footpath_start_bridge_at_point(sint32 screenX, sint32 screenY)
|
||||
{
|
||||
sint32 x, y, z, direction;
|
||||
rct_tile_element * mapElement;
|
||||
rct_tile_element * tileElement;
|
||||
|
||||
footpath_bridge_get_info_from_pos(screenX, screenY, &x, &y, &direction, &mapElement);
|
||||
footpath_bridge_get_info_from_pos(screenX, screenY, &x, &y, &direction, &tileElement);
|
||||
if (x == LOCATION_NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SURFACE)
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
|
||||
{
|
||||
// If we start the path on a slope, the arrow is slightly raised, so we
|
||||
// expect the path to be slightly raised as well.
|
||||
uint8 slope = mapElement->properties.surface.slope;
|
||||
z = mapElement->base_height;
|
||||
uint8 slope = tileElement->properties.surface.slope;
|
||||
z = tileElement->base_height;
|
||||
if (slope & 0x10)
|
||||
{
|
||||
// Steep diagonal slope
|
||||
|
@ -979,12 +979,12 @@ static void window_footpath_start_bridge_at_point(sint32 screenX, sint32 screenY
|
|||
}
|
||||
else
|
||||
{
|
||||
z = mapElement->base_height;
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)
|
||||
z = tileElement->base_height;
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
|
||||
{
|
||||
if (mapElement->properties.path.type & 4)
|
||||
if (tileElement->properties.path.type & 4)
|
||||
{
|
||||
if (direction == (mapElement->properties.path.type & 3))
|
||||
if (direction == (tileElement->properties.path.type & 3))
|
||||
{
|
||||
z += 2;
|
||||
}
|
||||
|
@ -1064,12 +1064,12 @@ static void window_footpath_construct()
|
|||
*
|
||||
* rct2: 0x006A78EF
|
||||
*/
|
||||
static void footpath_remove_tile_element(rct_tile_element * mapElement)
|
||||
static void footpath_remove_tile_element(rct_tile_element * tileElement)
|
||||
{
|
||||
sint32 x, y, z;
|
||||
|
||||
z = mapElement->base_height;
|
||||
sint32 pathType = mapElement->properties.path.type;
|
||||
z = tileElement->base_height;
|
||||
sint32 pathType = tileElement->properties.path.type;
|
||||
if (pathType & 4)
|
||||
{
|
||||
pathType &= 3;
|
||||
|
@ -1082,16 +1082,16 @@ static void footpath_remove_tile_element(rct_tile_element * mapElement)
|
|||
|
||||
// Find a connected edge
|
||||
sint32 edge = gFootpathConstructDirection ^2;
|
||||
if (!(mapElement->properties.path.edges & (1 << edge)))
|
||||
if (!(tileElement->properties.path.edges & (1 << edge)))
|
||||
{
|
||||
edge = (edge + 1) & 3;
|
||||
if (!(mapElement->properties.path.edges & (1 << edge)))
|
||||
if (!(tileElement->properties.path.edges & (1 << edge)))
|
||||
{
|
||||
edge = (edge + 2) & 3;
|
||||
if (!(mapElement->properties.path.edges & (1 << edge)))
|
||||
if (!(tileElement->properties.path.edges & (1 << edge)))
|
||||
{
|
||||
edge = (edge - 1) & 3;
|
||||
if (!(mapElement->properties.path.edges & (1 << edge)))
|
||||
if (!(tileElement->properties.path.edges & (1 << edge)))
|
||||
{
|
||||
edge ^= 2;
|
||||
}
|
||||
|
@ -1104,7 +1104,7 @@ static void footpath_remove_tile_element(rct_tile_element * mapElement)
|
|||
footpath_remove(
|
||||
gFootpathConstructFromPosition.x,
|
||||
gFootpathConstructFromPosition.y,
|
||||
mapElement->base_height,
|
||||
tileElement->base_height,
|
||||
1
|
||||
);
|
||||
|
||||
|
@ -1125,7 +1125,7 @@ static void footpath_remove_tile_element(rct_tile_element * mapElement)
|
|||
*/
|
||||
static rct_tile_element * footpath_get_tile_element_to_remove()
|
||||
{
|
||||
rct_tile_element * mapElement;
|
||||
rct_tile_element * tileElement;
|
||||
sint32 x, y, z, zLow;
|
||||
|
||||
x = gFootpathConstructFromPosition.x / 32;
|
||||
|
@ -1138,38 +1138,38 @@ static rct_tile_element * footpath_get_tile_element_to_remove()
|
|||
z = (gFootpathConstructFromPosition.z >> 3) & 0xFF;
|
||||
zLow = z - 2;
|
||||
|
||||
mapElement = map_get_first_element_at(x, y);
|
||||
tileElement = map_get_first_element_at(x, y);
|
||||
do
|
||||
{
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
|
||||
{
|
||||
if (mapElement->base_height == z)
|
||||
if (tileElement->base_height == z)
|
||||
{
|
||||
if (mapElement->properties.path.type & 4)
|
||||
if (tileElement->properties.path.type & 4)
|
||||
{
|
||||
if (((mapElement->properties.path.type & 3) ^ 2) != gFootpathConstructDirection)
|
||||
if (((tileElement->properties.path.type & 3) ^ 2) != gFootpathConstructDirection)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
return mapElement;
|
||||
return tileElement;
|
||||
}
|
||||
else if (mapElement->base_height == zLow)
|
||||
else if (tileElement->base_height == zLow)
|
||||
{
|
||||
if (!(mapElement->properties.path.type & 4))
|
||||
if (!(tileElement->properties.path.type & 4))
|
||||
{
|
||||
if ((mapElement->properties.path.type & 3) == gFootpathConstructDirection)
|
||||
if ((tileElement->properties.path.type & 3) == gFootpathConstructDirection)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
return mapElement;
|
||||
return tileElement;
|
||||
}
|
||||
}
|
||||
}
|
||||
while (!tile_element_is_last_for_tile(mapElement++));
|
||||
while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
@ -1180,15 +1180,15 @@ static rct_tile_element * footpath_get_tile_element_to_remove()
|
|||
*/
|
||||
static void window_footpath_remove()
|
||||
{
|
||||
rct_tile_element * mapElement;
|
||||
rct_tile_element * tileElement;
|
||||
|
||||
_window_footpath_cost = MONEY32_UNDEFINED;
|
||||
footpath_provisional_update();
|
||||
|
||||
mapElement = footpath_get_tile_element_to_remove();
|
||||
if (mapElement != nullptr)
|
||||
tileElement = footpath_get_tile_element_to_remove();
|
||||
if (tileElement != nullptr)
|
||||
{
|
||||
footpath_remove_tile_element(mapElement);
|
||||
footpath_remove_tile_element(tileElement);
|
||||
}
|
||||
|
||||
window_footpath_set_enabled_and_pressed_widgets();
|
||||
|
|
|
@ -1194,14 +1194,14 @@ void window_guest_overview_tool_down(rct_window* w, rct_widgetindex widgetIndex,
|
|||
return;
|
||||
|
||||
sint32 dest_x, dest_y;
|
||||
rct_tile_element* mapElement;
|
||||
footpath_get_coordinates_from_pos(x, y + 16, &dest_x, &dest_y, nullptr, &mapElement);
|
||||
rct_tile_element* tileElement;
|
||||
footpath_get_coordinates_from_pos(x, y + 16, &dest_x, &dest_y, nullptr, &tileElement);
|
||||
|
||||
if (dest_x == LOCATION_NULL)
|
||||
return;
|
||||
|
||||
game_command_callback = game_command_callback_pickup_guest;
|
||||
game_do_command(w->number, GAME_COMMAND_FLAG_APPLY, 2, mapElement->base_height, GAME_COMMAND_PICKUP_GUEST, dest_x, dest_y);
|
||||
game_do_command(w->number, GAME_COMMAND_FLAG_APPLY, 2, tileElement->base_height, GAME_COMMAND_PICKUP_GUEST, dest_x, dest_y);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -1213,19 +1213,19 @@ static void window_map_set_land_rights_tool_update(sint32 x, sint32 y)
|
|||
*/
|
||||
static void place_park_entrance_get_map_position(sint32 x, sint32 y, sint16 *mapX, sint16 *mapY, sint16 *mapZ, sint32 *direction)
|
||||
{
|
||||
rct_tile_element *mapElement;
|
||||
rct_tile_element *tileElement;
|
||||
|
||||
sub_68A15E(x, y, mapX, mapY, direction, &mapElement);
|
||||
sub_68A15E(x, y, mapX, mapY, direction, &tileElement);
|
||||
if (*mapX == LOCATION_NULL)
|
||||
return;
|
||||
|
||||
mapElement = map_get_surface_element_at(*mapX >> 5, *mapY >> 5);
|
||||
*mapZ = map_get_water_height(mapElement);
|
||||
tileElement = map_get_surface_element_at(*mapX >> 5, *mapY >> 5);
|
||||
*mapZ = map_get_water_height(tileElement);
|
||||
if (*mapZ == 0) {
|
||||
*mapZ = mapElement->base_height / 2;
|
||||
if ((mapElement->properties.surface.slope & 0x0F) != 0) {
|
||||
*mapZ = tileElement->base_height / 2;
|
||||
if ((tileElement->properties.surface.slope & 0x0F) != 0) {
|
||||
(*mapZ)++;
|
||||
if (mapElement->properties.surface.slope & 0x10) {
|
||||
if (tileElement->properties.surface.slope & 0x10) {
|
||||
(*mapZ)++;
|
||||
}
|
||||
}
|
||||
|
@ -1284,20 +1284,20 @@ static void window_map_place_park_entrance_tool_update(sint32 x, sint32 y)
|
|||
static void window_map_set_peep_spawn_tool_update(sint32 x, sint32 y)
|
||||
{
|
||||
sint32 mapX, mapY, mapZ, direction;
|
||||
rct_tile_element *mapElement;
|
||||
rct_tile_element *tileElement;
|
||||
|
||||
map_invalidate_selection_rect();
|
||||
gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE;
|
||||
gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
|
||||
footpath_bridge_get_info_from_pos(x, y, &mapX, &mapY, &direction, &mapElement);
|
||||
footpath_bridge_get_info_from_pos(x, y, &mapX, &mapY, &direction, &tileElement);
|
||||
if ((mapX & 0xFFFF) == 0x8000)
|
||||
return;
|
||||
|
||||
mapZ = mapElement->base_height * 8;
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SURFACE) {
|
||||
if ((mapElement->properties.surface.slope & 0x0F) != 0)
|
||||
mapZ = tileElement->base_height * 8;
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE) {
|
||||
if ((tileElement->properties.surface.slope & 0x0F) != 0)
|
||||
mapZ += 16;
|
||||
if (mapElement->properties.surface.slope & 0x10)
|
||||
if (tileElement->properties.surface.slope & 0x10)
|
||||
mapZ += 16;
|
||||
}
|
||||
|
||||
|
@ -1347,24 +1347,24 @@ static void window_map_place_park_entrance_tool_down(sint32 x, sint32 y)
|
|||
*/
|
||||
static void window_map_set_peep_spawn_tool_down(sint32 x, sint32 y)
|
||||
{
|
||||
rct_tile_element *mapElement, *surfaceMapElement;
|
||||
rct_tile_element *tileElement, *surfaceTileElement;
|
||||
sint32 mapX, mapY, mapZ, direction;
|
||||
|
||||
footpath_get_coordinates_from_pos(x, y, &mapX, &mapY, &direction, &mapElement);
|
||||
footpath_get_coordinates_from_pos(x, y, &mapX, &mapY, &direction, &tileElement);
|
||||
if (mapX == 0x8000)
|
||||
return;
|
||||
|
||||
surfaceMapElement = map_get_surface_element_at(mapX >> 5, mapY >> 5);
|
||||
if (surfaceMapElement == nullptr) {
|
||||
surfaceTileElement = map_get_surface_element_at(mapX >> 5, mapY >> 5);
|
||||
if (surfaceTileElement == nullptr) {
|
||||
return;
|
||||
}
|
||||
if (surfaceMapElement->properties.surface.ownership & 0xF0) {
|
||||
if (surfaceTileElement->properties.surface.ownership & 0xF0) {
|
||||
return;
|
||||
}
|
||||
|
||||
mapX = mapX + 16 + (word_981D6C[direction].x * 15);
|
||||
mapY = mapY + 16 + (word_981D6C[direction].y * 15);
|
||||
mapZ = mapElement->base_height / 2;
|
||||
mapZ = tileElement->base_height / 2;
|
||||
|
||||
sint32 peepSpawnIndex = -1;
|
||||
for (sint32 i = 0; i < MAX_PEEP_SPAWNS; i++) {
|
||||
|
@ -1578,25 +1578,25 @@ static const uint8 RideColourKey[] = {
|
|||
|
||||
static uint16 map_window_get_pixel_colour_peep(sint32 x, sint32 y)
|
||||
{
|
||||
rct_tile_element *mapElement;
|
||||
rct_tile_element *tileElement;
|
||||
uint16 colour;
|
||||
|
||||
mapElement = map_get_surface_element_at(x >> 5, y >> 5);
|
||||
colour = TerrainColour[tile_element_get_terrain(mapElement)];
|
||||
if (map_get_water_height(mapElement) > 0)
|
||||
tileElement = map_get_surface_element_at(x >> 5, y >> 5);
|
||||
colour = TerrainColour[tile_element_get_terrain(tileElement)];
|
||||
if (map_get_water_height(tileElement) > 0)
|
||||
colour = WaterColour;
|
||||
|
||||
if (!(mapElement->properties.surface.ownership & OWNERSHIP_OWNED))
|
||||
if (!(tileElement->properties.surface.ownership & OWNERSHIP_OWNED))
|
||||
colour = PALETTE_INDEX_10 | (colour & 0xFF00);
|
||||
|
||||
const sint32 maxSupportedMapElementType = (sint32)Util::CountOf(ElementTypeAddColour);
|
||||
while (!tile_element_is_last_for_tile(mapElement++)) {
|
||||
sint32 mapElementType = tile_element_get_type(mapElement) >> 2;
|
||||
if (mapElementType >= maxSupportedMapElementType) {
|
||||
mapElementType = TILE_ELEMENT_TYPE_CORRUPT >> 2;
|
||||
const sint32 maxSupportedTileElementType = (sint32)Util::CountOf(ElementTypeAddColour);
|
||||
while (!tile_element_is_last_for_tile(tileElement++)) {
|
||||
sint32 tileElementType = tile_element_get_type(tileElement) >> 2;
|
||||
if (tileElementType >= maxSupportedTileElementType) {
|
||||
tileElementType = TILE_ELEMENT_TYPE_CORRUPT >> 2;
|
||||
}
|
||||
colour &= ElementTypeMaskColour[mapElementType];
|
||||
colour |= ElementTypeAddColour[mapElementType];
|
||||
colour &= ElementTypeMaskColour[tileElementType];
|
||||
colour |= ElementTypeAddColour[tileElementType];
|
||||
}
|
||||
|
||||
return colour;
|
||||
|
@ -1604,20 +1604,20 @@ static uint16 map_window_get_pixel_colour_peep(sint32 x, sint32 y)
|
|||
|
||||
static uint16 map_window_get_pixel_colour_ride(sint32 x, sint32 y)
|
||||
{
|
||||
rct_tile_element *mapElement;
|
||||
rct_tile_element *tileElement;
|
||||
Ride *ride;
|
||||
uint32 colour;
|
||||
|
||||
colour = FALLBACK_COLOUR(PALETTE_INDEX_13);
|
||||
mapElement = map_get_surface_element_at(x >> 5, y >> 5);
|
||||
tileElement = map_get_surface_element_at(x >> 5, y >> 5);
|
||||
do {
|
||||
switch (tile_element_get_type(mapElement)) {
|
||||
switch (tile_element_get_type(tileElement)) {
|
||||
case TILE_ELEMENT_TYPE_SURFACE:
|
||||
if (map_get_water_height(mapElement) > 0) {
|
||||
if (map_get_water_height(tileElement) > 0) {
|
||||
colour &= 0xFFFF;
|
||||
colour |= FALLBACK_COLOUR(PALETTE_INDEX_194);
|
||||
}
|
||||
if (!(mapElement->properties.surface.ownership & OWNERSHIP_OWNED)) {
|
||||
if (!(tileElement->properties.surface.ownership & OWNERSHIP_OWNED)) {
|
||||
colour &= 0xFF00FFFF;
|
||||
colour |= PALETTE_INDEX_10 << 16;
|
||||
}
|
||||
|
@ -1626,15 +1626,15 @@ static uint16 map_window_get_pixel_colour_ride(sint32 x, sint32 y)
|
|||
colour = MAP_COLOUR(PALETTE_INDEX_14);
|
||||
break;
|
||||
case TILE_ELEMENT_TYPE_ENTRANCE:
|
||||
if (mapElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE)
|
||||
if (tileElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE)
|
||||
break;
|
||||
// fall-through
|
||||
case TILE_ELEMENT_TYPE_TRACK:
|
||||
ride = get_ride(mapElement->properties.track.ride_index);
|
||||
ride = get_ride(tileElement->properties.track.ride_index);
|
||||
colour = RideKeyColours[RideColourKey[ride->type]];
|
||||
break;
|
||||
}
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
if ((colour & 0xFFFF) == 0)
|
||||
colour >>= 16;
|
||||
|
|
|
@ -1132,14 +1132,14 @@ void window_staff_overview_tool_down(rct_window* w, rct_widgetindex widgetIndex,
|
|||
{
|
||||
if (widgetIndex == WIDX_PICKUP) {
|
||||
sint32 dest_x, dest_y;
|
||||
rct_tile_element* mapElement;
|
||||
footpath_get_coordinates_from_pos(x, y + 16, &dest_x, &dest_y, nullptr, &mapElement);
|
||||
rct_tile_element* tileElement;
|
||||
footpath_get_coordinates_from_pos(x, y + 16, &dest_x, &dest_y, nullptr, &tileElement);
|
||||
|
||||
if (dest_x == LOCATION_NULL)
|
||||
return;
|
||||
|
||||
game_command_callback = game_command_callback_pickup_staff;
|
||||
game_do_command(w->number, GAME_COMMAND_FLAG_APPLY, 2, mapElement->base_height, GAME_COMMAND_PICKUP_STAFF, dest_x, dest_y);
|
||||
game_do_command(w->number, GAME_COMMAND_FLAG_APPLY, 2, tileElement->base_height, GAME_COMMAND_PICKUP_STAFF, dest_x, dest_y);
|
||||
}
|
||||
else if (widgetIndex == WIDX_PATROL){
|
||||
sint32 dest_x, dest_y;
|
||||
|
|
|
@ -336,8 +336,8 @@ static void window_staff_list_tooldown(rct_window *w, rct_widgetindex widgetInde
|
|||
sint32 selectedPeepType = _windowStaffListSelectedTab;
|
||||
|
||||
sint32 direction;
|
||||
rct_tile_element *mapElement;
|
||||
footpath_get_coordinates_from_pos(x, y, &x, &y, &direction, &mapElement);
|
||||
rct_tile_element *tileElement;
|
||||
footpath_get_coordinates_from_pos(x, y, &x, &y, &direction, &tileElement);
|
||||
if (x == 0x8000)
|
||||
return;
|
||||
|
||||
|
|
|
@ -169,9 +169,9 @@ static LocationXY16 get_location()
|
|||
rct_window *w = window_get_main();
|
||||
if (w != nullptr) {
|
||||
sint32 interactionType;
|
||||
rct_tile_element *mapElement;
|
||||
rct_tile_element *tileElement;
|
||||
|
||||
get_map_coordinates_from_pos_window(w, w->viewport->view_width / 2, w->viewport->view_height / 2, VIEWPORT_INTERACTION_MASK_TERRAIN, &mapCoord.x, &mapCoord.y, &interactionType, &mapElement, nullptr);
|
||||
get_map_coordinates_from_pos_window(w, w->viewport->view_width / 2, w->viewport->view_height / 2, VIEWPORT_INTERACTION_MASK_TERRAIN, &mapCoord.x, &mapCoord.y, &interactionType, &tileElement, nullptr);
|
||||
mapCoord.x -= 16;
|
||||
mapCoord.x /= 32;
|
||||
mapCoord.y -= 16;
|
||||
|
|
|
@ -406,24 +406,24 @@ static void window_track_place_clear_provisional()
|
|||
*/
|
||||
static sint32 window_track_place_get_base_z(sint32 x, sint32 y)
|
||||
{
|
||||
rct_tile_element *mapElement;
|
||||
rct_tile_element *tileElement;
|
||||
sint32 z;
|
||||
|
||||
mapElement = map_get_surface_element_at(x >> 5, y >> 5);
|
||||
z = mapElement->base_height * 8;
|
||||
tileElement = map_get_surface_element_at(x >> 5, y >> 5);
|
||||
z = tileElement->base_height * 8;
|
||||
|
||||
// Increase Z above slope
|
||||
if (mapElement->properties.surface.slope & 0x0F) {
|
||||
if (tileElement->properties.surface.slope & 0x0F) {
|
||||
z += 16;
|
||||
|
||||
// Increase Z above double slope
|
||||
if (mapElement->properties.surface.slope & 0x10)
|
||||
if (tileElement->properties.surface.slope & 0x10)
|
||||
z += 16;
|
||||
}
|
||||
|
||||
// Increase Z above water
|
||||
if (map_get_water_height(mapElement) > 0)
|
||||
z = Math::Max(z, map_get_water_height(mapElement) << 4);
|
||||
if (map_get_water_height(tileElement) > 0)
|
||||
z = Math::Max(z, map_get_water_height(tileElement) << 4);
|
||||
|
||||
return z + place_virtual_track(_trackDesign, PTD_OPERATION_GET_PLACE_Z, true, 0, x, y, z);
|
||||
}
|
||||
|
|
|
@ -60,21 +60,21 @@ sint32 park_rating_spinner_value;
|
|||
static void cheat_set_grass_length(sint32 length)
|
||||
{
|
||||
sint32 x, y;
|
||||
rct_tile_element *mapElement;
|
||||
rct_tile_element *tileElement;
|
||||
|
||||
for (y = 0; y < 256; y++) {
|
||||
for (x = 0; x < 256; x++) {
|
||||
mapElement = map_get_surface_element_at(x, y);
|
||||
if (!(mapElement->properties.surface.ownership & OWNERSHIP_OWNED))
|
||||
tileElement = map_get_surface_element_at(x, y);
|
||||
if (!(tileElement->properties.surface.ownership & OWNERSHIP_OWNED))
|
||||
continue;
|
||||
|
||||
if (tile_element_get_terrain(mapElement) != TERRAIN_GRASS)
|
||||
if (tile_element_get_terrain(tileElement) != TERRAIN_GRASS)
|
||||
continue;
|
||||
|
||||
if (map_get_water_height(mapElement) > 0)
|
||||
if (map_get_water_height(tileElement) > 0)
|
||||
continue;
|
||||
|
||||
mapElement->properties.surface.grass_length = length;
|
||||
tileElement->properties.surface.grass_length = length;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -278,13 +278,13 @@ void lightfx_prepare_light_list()
|
|||
for (sint32 pat = startSamplePoint; pat < totalSamplePoints; pat++) {
|
||||
LocationXY16 mapCoord = { 0 };
|
||||
|
||||
rct_tile_element *mapElement = 0;
|
||||
rct_tile_element *tileElement = 0;
|
||||
|
||||
sint32 interactionType = 0;
|
||||
|
||||
rct_window *w = window_get_main();
|
||||
if (w != NULL) {
|
||||
// get_map_coordinates_from_pos(entry->x + offsetPattern[pat*2] / mapFrontDiv, entry->y + offsetPattern[pat*2+1] / mapFrontDiv, VIEWPORT_INTERACTION_MASK_NONE, &mapCoord.x, &mapCoord.y, &interactionType, &mapElement, NULL);
|
||||
// get_map_coordinates_from_pos(entry->x + offsetPattern[pat*2] / mapFrontDiv, entry->y + offsetPattern[pat*2+1] / mapFrontDiv, VIEWPORT_INTERACTION_MASK_NONE, &mapCoord.x, &mapCoord.y, &interactionType, &tileElement, NULL);
|
||||
|
||||
#ifdef LIGHTFX_UNKNOWN_PART_1
|
||||
_unk9AC154 = ~VIEWPORT_INTERACTION_MASK_SPRITE & 0xFFFF;
|
||||
|
@ -309,7 +309,7 @@ void lightfx_prepare_light_list()
|
|||
mapCoord.x = _interactionMapX + tileOffsetX;
|
||||
mapCoord.y = _interactionMapY + tileOffsetY;
|
||||
interactionType = _interactionSpriteType;
|
||||
mapElement = RCT2_GLOBAL(0x9AC150, rct_tile_element*);
|
||||
tileElement = RCT2_GLOBAL(0x9AC150, rct_tile_element*);
|
||||
#endif //LIGHTFX_UNKNOWN_PART_1
|
||||
|
||||
//RCT2_GLOBAL(0x9AC154, uint16_t) = VIEWPORT_INTERACTION_MASK_NONE;
|
||||
|
@ -345,8 +345,8 @@ void lightfx_prepare_light_list()
|
|||
sint32 minDist = 0;
|
||||
sint32 baseHeight = -999;
|
||||
|
||||
if (interactionType != VIEWPORT_INTERACTION_ITEM_SPRITE && mapElement) {
|
||||
baseHeight = mapElement->base_height;
|
||||
if (interactionType != VIEWPORT_INTERACTION_ITEM_SPRITE && tileElement) {
|
||||
baseHeight = tileElement->base_height;
|
||||
}
|
||||
|
||||
minDist = ((baseHeight * 8) - coord_3d.z) / 2;
|
||||
|
|
|
@ -1070,25 +1070,25 @@ void game_fix_save_vars()
|
|||
// and broken saves with incorrect invisible map border tiles
|
||||
for (sint32 y = 0; y < 256; y++) {
|
||||
for (sint32 x = 0; x < 256; x++) {
|
||||
rct_tile_element *mapElement = map_get_surface_element_at(x, y);
|
||||
rct_tile_element *tileElement = map_get_surface_element_at(x, y);
|
||||
|
||||
if (mapElement == NULL)
|
||||
if (tileElement == NULL)
|
||||
{
|
||||
log_error("Null map element at x = %d and y = %d. Fixing...", x, y);
|
||||
mapElement = tile_element_insert(x, y, 14, 0);
|
||||
if (mapElement == NULL) {
|
||||
tileElement = tile_element_insert(x, y, 14, 0);
|
||||
if (tileElement == NULL) {
|
||||
log_error("Unable to fix: Map element limit reached.");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Fix the invisible border tiles.
|
||||
// At this point, we can be sure that mapElement is not NULL.
|
||||
// At this point, we can be sure that tileElement is not NULL.
|
||||
if (x == 0 || x == gMapSize - 1 || y == 0 || y == gMapSize -1)
|
||||
{
|
||||
mapElement->base_height = 2;
|
||||
mapElement->clearance_height = 2;
|
||||
mapElement->properties.surface.slope = 0;
|
||||
tileElement->base_height = 2;
|
||||
tileElement->clearance_height = 2;
|
||||
tileElement->properties.surface.slope = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -85,7 +85,7 @@ void process_mouse_over(sint32 x, sint32 y);
|
|||
void process_mouse_tool(sint32 x, sint32 y);
|
||||
void invalidate_scroll();
|
||||
static rct_mouse_data* get_mouse_input();
|
||||
void tile_element_right_click(sint32 type, rct_tile_element *mapElement, sint32 x, sint32 y);
|
||||
void tile_element_right_click(sint32 type, rct_tile_element *tileElement, sint32 x, sint32 y);
|
||||
static void game_handle_input_mouse(sint32 x, sint32 y, sint32 state);
|
||||
static void input_widget_left(sint32 x, sint32 y, rct_window *w, rct_widgetindex widgetIndex);
|
||||
void input_state_widget_pressed(sint32 x, sint32 y, sint32 state, rct_widgetindex widgetIndex, rct_window* w, rct_widget* widget);
|
||||
|
|
|
@ -818,9 +818,9 @@ static sint32 cc_get(const utf8 **argv, sint32 argc)
|
|||
rct_window *w = window_get_main();
|
||||
if (w != NULL) {
|
||||
sint32 interactionType;
|
||||
rct_tile_element *mapElement;
|
||||
rct_tile_element *tileElement;
|
||||
LocationXY16 mapCoord = { 0 };
|
||||
get_map_coordinates_from_pos(w->viewport->view_width / 2, w->viewport->view_height / 2, VIEWPORT_INTERACTION_MASK_TERRAIN, &mapCoord.x, &mapCoord.y, &interactionType, &mapElement, NULL);
|
||||
get_map_coordinates_from_pos(w->viewport->view_width / 2, w->viewport->view_height / 2, VIEWPORT_INTERACTION_MASK_TERRAIN, &mapCoord.x, &mapCoord.y, &interactionType, &tileElement, NULL);
|
||||
mapCoord.x -= 16;
|
||||
mapCoord.x /= 32;
|
||||
mapCoord.y -= 16;
|
||||
|
@ -1269,7 +1269,7 @@ static sint32 cc_remove_park_fences(const utf8 **argv, sint32 argc)
|
|||
static sint32 cc_show_limits(const utf8 ** argv, sint32 argc)
|
||||
{
|
||||
map_reorganise_elements();
|
||||
sint32 mapElementCount = gNextFreeMapElement - gMapElements - 1;
|
||||
sint32 tileElementCount = gNextFreeTileElement - gTileElements - 1;
|
||||
|
||||
sint32 rideCount = 0;
|
||||
for (sint32 i = 0; i < MAX_RIDES; ++i)
|
||||
|
@ -1306,7 +1306,7 @@ static sint32 cc_show_limits(const utf8 ** argv, sint32 argc)
|
|||
}
|
||||
|
||||
console_printf("Sprites: %d/%d", spriteCount, MAX_SPRITES);
|
||||
console_printf("Map Elements: %d/%d", mapElementCount, MAX_TILE_ELEMENTS);
|
||||
console_printf("Map Elements: %d/%d", tileElementCount, MAX_TILE_ELEMENTS);
|
||||
console_printf("Banners: %d/%d", bannerCount, MAX_BANNERS);
|
||||
console_printf("Rides: %d/%d", rideCount, MAX_RIDES);
|
||||
console_printf("Staff: %d/%d", staffCount, STAFF_MAX_COUNT);
|
||||
|
|
|
@ -1025,7 +1025,7 @@ static void store_interaction_info(paint_struct *ps)
|
|||
_interactionSpriteType = ps->sprite_type;
|
||||
_interactionMapX = ps->map_x;
|
||||
_interactionMapY = ps->map_y;
|
||||
_interaction_element = ps->mapElement;
|
||||
_interaction_element = ps->tileElement;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1344,17 +1344,17 @@ static void sub_68862C(rct_drawpixelinfo * dpi, paint_struct * ps)
|
|||
* x: ax
|
||||
* y: cx
|
||||
* interactionType: bl
|
||||
* mapElement: edx
|
||||
* tileElement: edx
|
||||
* viewport: edi
|
||||
*/
|
||||
void get_map_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 flags, sint16 *x, sint16 *y, sint32 *interactionType, rct_tile_element **mapElement, rct_viewport **viewport)
|
||||
void get_map_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 flags, sint16 *x, sint16 *y, sint32 *interactionType, rct_tile_element **tileElement, rct_viewport **viewport)
|
||||
{
|
||||
rct_window* window = window_find_from_point(screenX, screenY);
|
||||
get_map_coordinates_from_pos_window(window, screenX, screenY, flags, x, y, interactionType, mapElement, viewport);
|
||||
get_map_coordinates_from_pos_window(window, screenX, screenY, flags, x, y, interactionType, tileElement, viewport);
|
||||
}
|
||||
|
||||
void get_map_coordinates_from_pos_window(rct_window * window, sint32 screenX, sint32 screenY, sint32 flags, sint16 * x, sint16 * y,
|
||||
sint32 * interactionType, rct_tile_element ** mapElement, rct_viewport ** viewport)
|
||||
sint32 * interactionType, rct_tile_element ** tileElement, rct_viewport ** viewport)
|
||||
{
|
||||
_unk9AC154 = flags & 0xFFFF;
|
||||
_interactionSpriteType = 0;
|
||||
|
@ -1392,7 +1392,7 @@ void get_map_coordinates_from_pos_window(rct_window * window, sint32 screenX, si
|
|||
if (interactionType != NULL) *interactionType = _interactionSpriteType;
|
||||
if (x != NULL) *x = _interactionMapX;
|
||||
if (y != NULL) *y = _interactionMapY;
|
||||
if (mapElement != NULL) *mapElement = _interaction_element;
|
||||
if (tileElement != NULL) *tileElement = _interaction_element;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -80,7 +80,7 @@ typedef struct viewport_interaction_info {
|
|||
sint32 x;
|
||||
sint32 y;
|
||||
union {
|
||||
rct_tile_element *mapElement;
|
||||
rct_tile_element *tileElement;
|
||||
rct_sprite *sprite;
|
||||
rct_peep *peep;
|
||||
rct_vehicle *vehicle;
|
||||
|
@ -142,9 +142,9 @@ void show_construction_rights();
|
|||
void hide_construction_rights();
|
||||
void viewport_set_visibility(uint8 mode);
|
||||
|
||||
void get_map_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 flags, sint16 *x, sint16 *y, sint32 *interactionType, rct_tile_element **mapElement, rct_viewport **viewport);
|
||||
void get_map_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 flags, sint16 *x, sint16 *y, sint32 *interactionType, rct_tile_element **tileElement, rct_viewport **viewport);
|
||||
void get_map_coordinates_from_pos_window(rct_window * window, sint32 screenX, sint32 screenY, sint32 flags, sint16 * x, sint16 * y,
|
||||
sint32 * interactionType, rct_tile_element ** mapElement, rct_viewport ** viewport);
|
||||
sint32 * interactionType, rct_tile_element ** tileElement, rct_viewport ** viewport);
|
||||
|
||||
sint32 viewport_interaction_get_item_left(sint32 x, sint32 y, viewport_interaction_info *info);
|
||||
sint32 viewport_interaction_left_over(sint32 x, sint32 y);
|
||||
|
@ -152,9 +152,9 @@ sint32 viewport_interaction_left_click(sint32 x, sint32 y);
|
|||
sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interaction_info *info);
|
||||
sint32 viewport_interaction_right_over(sint32 x, sint32 y);
|
||||
sint32 viewport_interaction_right_click(sint32 x, sint32 y);
|
||||
void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *direction, rct_tile_element **mapElement);
|
||||
void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *direction, rct_tile_element **tileElement);
|
||||
|
||||
void viewport_interaction_remove_park_entrance(rct_tile_element *mapElement, sint32 x, sint32 y);
|
||||
void viewport_interaction_remove_park_entrance(rct_tile_element *tileElement, sint32 x, sint32 y);
|
||||
|
||||
void sub_68B2B7(paint_session * session, sint32 x, sint32 y);
|
||||
|
||||
|
|
|
@ -33,11 +33,11 @@
|
|||
#include "viewport.h"
|
||||
#include "../Context.h"
|
||||
|
||||
static void viewport_interaction_remove_scenery(rct_tile_element *mapElement, sint32 x, sint32 y);
|
||||
static void viewport_interaction_remove_footpath(rct_tile_element *mapElement, sint32 x, sint32 y);
|
||||
static void viewport_interaction_remove_footpath_item(rct_tile_element *mapElement, sint32 x, sint32 y);
|
||||
static void viewport_interaction_remove_park_wall(rct_tile_element *mapElement, sint32 x, sint32 y);
|
||||
static void viewport_interaction_remove_large_scenery(rct_tile_element *mapElement, sint32 x, sint32 y);
|
||||
static void viewport_interaction_remove_scenery(rct_tile_element *tileElement, sint32 x, sint32 y);
|
||||
static void viewport_interaction_remove_footpath(rct_tile_element *tileElement, sint32 x, sint32 y);
|
||||
static void viewport_interaction_remove_footpath_item(rct_tile_element *tileElement, sint32 x, sint32 y);
|
||||
static void viewport_interaction_remove_park_wall(rct_tile_element *tileElement, sint32 x, sint32 y);
|
||||
static void viewport_interaction_remove_large_scenery(rct_tile_element *tileElement, sint32 x, sint32 y);
|
||||
static rct_peep *viewport_interaction_get_closest_peep(sint32 x, sint32 y, sint32 maxDistance);
|
||||
|
||||
/**
|
||||
|
@ -46,7 +46,7 @@ static rct_peep *viewport_interaction_get_closest_peep(sint32 x, sint32 y, sint3
|
|||
*/
|
||||
sint32 viewport_interaction_get_item_left(sint32 x, sint32 y, viewport_interaction_info *info)
|
||||
{
|
||||
rct_tile_element *mapElement;
|
||||
rct_tile_element *tileElement;
|
||||
rct_sprite *sprite;
|
||||
rct_vehicle *vehicle;
|
||||
|
||||
|
@ -59,11 +59,11 @@ sint32 viewport_interaction_get_item_left(sint32 x, sint32 y, viewport_interacti
|
|||
return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
|
||||
|
||||
LocationXY16 mapCoord = { 0 };
|
||||
get_map_coordinates_from_pos(x, y, VIEWPORT_INTERACTION_MASK_SPRITE & VIEWPORT_INTERACTION_MASK_RIDE & VIEWPORT_INTERACTION_MASK_PARK, &mapCoord.x, &mapCoord.y, &info->type, &info->mapElement, NULL);
|
||||
get_map_coordinates_from_pos(x, y, VIEWPORT_INTERACTION_MASK_SPRITE & VIEWPORT_INTERACTION_MASK_RIDE & VIEWPORT_INTERACTION_MASK_PARK, &mapCoord.x, &mapCoord.y, &info->type, &info->tileElement, NULL);
|
||||
info->x = mapCoord.x;
|
||||
info->y = mapCoord.y;
|
||||
mapElement = info->mapElement;
|
||||
sprite = (rct_sprite*)mapElement;
|
||||
tileElement = info->tileElement;
|
||||
sprite = (rct_sprite*)tileElement;
|
||||
|
||||
switch (info->type) {
|
||||
case VIEWPORT_INTERACTION_ITEM_SPRITE:
|
||||
|
@ -81,7 +81,7 @@ sint32 viewport_interaction_get_item_left(sint32 x, sint32 y, viewport_interacti
|
|||
}
|
||||
break;
|
||||
case VIEWPORT_INTERACTION_ITEM_RIDE:
|
||||
ride_set_map_tooltip(mapElement);
|
||||
ride_set_map_tooltip(tileElement);
|
||||
break;
|
||||
case VIEWPORT_INTERACTION_ITEM_PARK:
|
||||
set_map_tooltip_format_arg(0, rct_string_id, gParkName);
|
||||
|
@ -154,7 +154,7 @@ sint32 viewport_interaction_left_click(sint32 x, sint32 y)
|
|||
}
|
||||
return 1;
|
||||
case VIEWPORT_INTERACTION_ITEM_RIDE:
|
||||
window_ride_open_track(info.mapElement);
|
||||
window_ride_open_track(info.tileElement);
|
||||
return 1;
|
||||
case VIEWPORT_INTERACTION_ITEM_PARK:
|
||||
context_open_window(WC_PARK_INFORMATION);
|
||||
|
@ -170,7 +170,7 @@ sint32 viewport_interaction_left_click(sint32 x, sint32 y)
|
|||
*/
|
||||
sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interaction_info *info)
|
||||
{
|
||||
rct_tile_element *mapElement;
|
||||
rct_tile_element *tileElement;
|
||||
rct_scenery_entry *sceneryEntry;
|
||||
rct_banner *banner;
|
||||
Ride *ride;
|
||||
|
@ -185,18 +185,18 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
|
||||
|
||||
LocationXY16 mapCoord = { 0 };
|
||||
get_map_coordinates_from_pos(x, y, ~(VIEWPORT_INTERACTION_MASK_TERRAIN & VIEWPORT_INTERACTION_MASK_WATER), &mapCoord.x, &mapCoord.y, &info->type, &info->mapElement, NULL);
|
||||
get_map_coordinates_from_pos(x, y, ~(VIEWPORT_INTERACTION_MASK_TERRAIN & VIEWPORT_INTERACTION_MASK_WATER), &mapCoord.x, &mapCoord.y, &info->type, &info->tileElement, NULL);
|
||||
info->x = mapCoord.x;
|
||||
info->y = mapCoord.y;
|
||||
mapElement = info->mapElement;
|
||||
tileElement = info->tileElement;
|
||||
|
||||
switch (info->type) {
|
||||
case VIEWPORT_INTERACTION_ITEM_SPRITE:
|
||||
if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || mapElement->type != 0)
|
||||
if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || tileElement->type != 0)
|
||||
return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
|
||||
|
||||
mapElement += 6;
|
||||
ride = get_ride(mapElement->type);
|
||||
tileElement += 6;
|
||||
ride = get_ride(tileElement->type);
|
||||
if (ride->status == RIDE_STATUS_CLOSED) {
|
||||
set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY);
|
||||
set_map_tooltip_format_arg(2, rct_string_id, ride->name);
|
||||
|
@ -207,18 +207,18 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
case VIEWPORT_INTERACTION_ITEM_RIDE:
|
||||
if (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR)
|
||||
return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
|
||||
return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
|
||||
|
||||
ride = get_ride(mapElement->properties.track.ride_index);
|
||||
ride = get_ride(tileElement->properties.track.ride_index);
|
||||
if (ride->status != RIDE_STATUS_CLOSED)
|
||||
return info->type;
|
||||
|
||||
set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY);
|
||||
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
|
||||
rct_string_id stringId;
|
||||
if (mapElement->properties.track.type == ENTRANCE_TYPE_RIDE_ENTRANCE) {
|
||||
if (tileElement->properties.track.type == ENTRANCE_TYPE_RIDE_ENTRANCE) {
|
||||
if (ride->num_stations > 1) {
|
||||
stringId = STR_RIDE_STATION_X_ENTRANCE;
|
||||
} else {
|
||||
|
@ -232,7 +232,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
}
|
||||
}
|
||||
set_map_tooltip_format_arg(2, rct_string_id, stringId);
|
||||
} else if (track_element_is_station(mapElement)) {
|
||||
} else if (track_element_is_station(tileElement)) {
|
||||
rct_string_id stringId;
|
||||
if (ride->num_stations > 1) {
|
||||
stringId = STR_RIDE_STATION_X;
|
||||
|
@ -241,7 +241,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
}
|
||||
set_map_tooltip_format_arg(2, rct_string_id, stringId);
|
||||
} else {
|
||||
if (!gCheatsSandboxMode && !map_is_location_owned(info->x, info->y, mapElement->base_height << 4)) {
|
||||
if (!gCheatsSandboxMode && !map_is_location_owned(info->x, info->y, tileElement->base_height << 4)) {
|
||||
return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
|
||||
}
|
||||
|
||||
|
@ -254,7 +254,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
set_map_tooltip_format_arg(6, uint32, ride->name_arguments);
|
||||
set_map_tooltip_format_arg(10, rct_string_id, RideComponentNames[RideNameConvention[ride->type].station].capitalised);
|
||||
|
||||
stationIndex = tile_element_get_station(mapElement);
|
||||
stationIndex = tile_element_get_station(tileElement);
|
||||
for (i = stationIndex; i >= 0; i--)
|
||||
if (ride->station_starts[i].xy == RCT_XY8_UNDEFINED)
|
||||
stationIndex--;
|
||||
|
@ -263,7 +263,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
return info->type;
|
||||
|
||||
case VIEWPORT_INTERACTION_ITEM_WALL:
|
||||
sceneryEntry = get_wall_entry(mapElement->properties.scenery.type);
|
||||
sceneryEntry = get_wall_entry(tileElement->properties.scenery.type);
|
||||
if (sceneryEntry->wall.scrolling_mode != 255) {
|
||||
set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY);
|
||||
set_map_tooltip_format_arg(2, rct_string_id, sceneryEntry->name);
|
||||
|
@ -272,7 +272,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
break;
|
||||
|
||||
case VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY:
|
||||
sceneryEntry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & 0x3FF);
|
||||
sceneryEntry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & 0x3FF);
|
||||
if (sceneryEntry->large_scenery.scrolling_mode != 255) {
|
||||
set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY);
|
||||
set_map_tooltip_format_arg(2, rct_string_id, sceneryEntry->name);
|
||||
|
@ -281,7 +281,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
break;
|
||||
|
||||
case VIEWPORT_INTERACTION_ITEM_BANNER:
|
||||
banner = &gBanners[mapElement->properties.banner.index];
|
||||
banner = &gBanners[tileElement->properties.banner.index];
|
||||
sceneryEntry = get_banner_entry(banner->type);
|
||||
|
||||
set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY);
|
||||
|
@ -297,7 +297,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
|
||||
switch (info->type) {
|
||||
case VIEWPORT_INTERACTION_ITEM_SCENERY:
|
||||
sceneryEntry = get_small_scenery_entry(mapElement->properties.scenery.type);
|
||||
sceneryEntry = get_small_scenery_entry(tileElement->properties.scenery.type);
|
||||
set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
|
||||
set_map_tooltip_format_arg(2, rct_string_id, sceneryEntry->name);
|
||||
return info->type;
|
||||
|
@ -305,14 +305,14 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
case VIEWPORT_INTERACTION_ITEM_FOOTPATH:
|
||||
set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
|
||||
set_map_tooltip_format_arg(2, rct_string_id, STR_FOOTPATH_MAP_TIP);
|
||||
if (mapElement->type & 1)
|
||||
if (tileElement->type & 1)
|
||||
set_map_tooltip_format_arg(2, rct_string_id, STR_QUEUE_LINE_MAP_TIP);
|
||||
return info->type;
|
||||
|
||||
case VIEWPORT_INTERACTION_ITEM_FOOTPATH_ITEM:
|
||||
sceneryEntry = get_footpath_item_entry(footpath_element_get_path_scenery_index(mapElement));
|
||||
sceneryEntry = get_footpath_item_entry(footpath_element_get_path_scenery_index(tileElement));
|
||||
set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN) {
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN) {
|
||||
set_map_tooltip_format_arg(2, rct_string_id, STR_BROKEN);
|
||||
set_map_tooltip_format_arg(4, rct_string_id, sceneryEntry->name);
|
||||
} else {
|
||||
|
@ -324,7 +324,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
|
||||
break;
|
||||
|
||||
if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
|
||||
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
|
||||
break;
|
||||
|
||||
set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
|
||||
|
@ -332,13 +332,13 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
|
|||
return info->type;
|
||||
|
||||
case VIEWPORT_INTERACTION_ITEM_WALL:
|
||||
sceneryEntry = get_wall_entry(mapElement->properties.scenery.type);
|
||||
sceneryEntry = get_wall_entry(tileElement->properties.scenery.type);
|
||||
set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
|
||||
set_map_tooltip_format_arg(2, rct_string_id, sceneryEntry->name);
|
||||
return info->type;
|
||||
|
||||
case VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY:
|
||||
sceneryEntry = get_large_scenery_entry(mapElement->properties.scenery.type & 0x3FF);
|
||||
sceneryEntry = get_large_scenery_entry(tileElement->properties.scenery.type & 0x3FF);
|
||||
set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
|
||||
set_map_tooltip_format_arg(2, rct_string_id, sceneryEntry->name);
|
||||
return info->type;
|
||||
|
@ -360,7 +360,7 @@ sint32 viewport_interaction_right_over(sint32 x, sint32 y)
|
|||
*/
|
||||
sint32 viewport_interaction_right_click(sint32 x, sint32 y)
|
||||
{
|
||||
rct_xy_element mapElement;
|
||||
rct_xy_element tileElement;
|
||||
viewport_interaction_info info;
|
||||
|
||||
switch (viewport_interaction_get_item_right(x, y, &info)) {
|
||||
|
@ -372,31 +372,31 @@ sint32 viewport_interaction_right_click(sint32 x, sint32 y)
|
|||
ride_construct(info.sprite->vehicle.ride);
|
||||
break;
|
||||
case VIEWPORT_INTERACTION_ITEM_RIDE:
|
||||
mapElement.x = info.x;
|
||||
mapElement.y = info.y;
|
||||
mapElement.element = info.mapElement;
|
||||
ride_modify(&mapElement);
|
||||
tileElement.x = info.x;
|
||||
tileElement.y = info.y;
|
||||
tileElement.element = info.tileElement;
|
||||
ride_modify(&tileElement);
|
||||
break;
|
||||
case VIEWPORT_INTERACTION_ITEM_SCENERY:
|
||||
viewport_interaction_remove_scenery(info.mapElement, info.x, info.y);
|
||||
viewport_interaction_remove_scenery(info.tileElement, info.x, info.y);
|
||||
break;
|
||||
case VIEWPORT_INTERACTION_ITEM_FOOTPATH:
|
||||
viewport_interaction_remove_footpath(info.mapElement, info.x, info.y);
|
||||
viewport_interaction_remove_footpath(info.tileElement, info.x, info.y);
|
||||
break;
|
||||
case VIEWPORT_INTERACTION_ITEM_FOOTPATH_ITEM:
|
||||
viewport_interaction_remove_footpath_item(info.mapElement, info.x, info.y);
|
||||
viewport_interaction_remove_footpath_item(info.tileElement, info.x, info.y);
|
||||
break;
|
||||
case VIEWPORT_INTERACTION_ITEM_PARK:
|
||||
viewport_interaction_remove_park_entrance(info.mapElement, info.x, info.y);
|
||||
viewport_interaction_remove_park_entrance(info.tileElement, info.x, info.y);
|
||||
break;
|
||||
case VIEWPORT_INTERACTION_ITEM_WALL:
|
||||
viewport_interaction_remove_park_wall(info.mapElement, info.x, info.y);
|
||||
viewport_interaction_remove_park_wall(info.tileElement, info.x, info.y);
|
||||
break;
|
||||
case VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY:
|
||||
viewport_interaction_remove_large_scenery(info.mapElement, info.x, info.y);
|
||||
viewport_interaction_remove_large_scenery(info.tileElement, info.x, info.y);
|
||||
break;
|
||||
case VIEWPORT_INTERACTION_ITEM_BANNER:
|
||||
context_open_detail_window(WD_BANNER, info.mapElement->properties.banner.index);
|
||||
context_open_detail_window(WD_BANNER, info.tileElement->properties.banner.index);
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -407,14 +407,14 @@ sint32 viewport_interaction_right_click(sint32 x, sint32 y)
|
|||
*
|
||||
* rct2: 0x006E08D2
|
||||
*/
|
||||
static void viewport_interaction_remove_scenery(rct_tile_element *mapElement, sint32 x, sint32 y)
|
||||
static void viewport_interaction_remove_scenery(rct_tile_element *tileElement, sint32 x, sint32 y)
|
||||
{
|
||||
gGameCommandErrorTitle = STR_CANT_REMOVE_THIS;
|
||||
game_do_command(
|
||||
x,
|
||||
(mapElement->type << 8) | 1,
|
||||
(tileElement->type << 8) | 1,
|
||||
y,
|
||||
(mapElement->properties.scenery.type << 8) | mapElement->base_height,
|
||||
(tileElement->properties.scenery.type << 8) | tileElement->base_height,
|
||||
GAME_COMMAND_REMOVE_SCENERY,
|
||||
0,
|
||||
0
|
||||
|
@ -425,46 +425,46 @@ static void viewport_interaction_remove_scenery(rct_tile_element *mapElement, si
|
|||
*
|
||||
* rct2: 0x006A614A
|
||||
*/
|
||||
static void viewport_interaction_remove_footpath(rct_tile_element *mapElement, sint32 x, sint32 y)
|
||||
static void viewport_interaction_remove_footpath(rct_tile_element *tileElement, sint32 x, sint32 y)
|
||||
{
|
||||
sint32 z;
|
||||
rct_window *w;
|
||||
rct_tile_element *mapElement2;
|
||||
rct_tile_element *tileElement2;
|
||||
|
||||
z = mapElement->base_height;
|
||||
z = tileElement->base_height;
|
||||
|
||||
w = window_find_by_class(WC_FOOTPATH);
|
||||
if (w != NULL)
|
||||
footpath_provisional_update();
|
||||
|
||||
mapElement2 = map_get_first_element_at(x / 32, y / 32);
|
||||
tileElement2 = map_get_first_element_at(x / 32, y / 32);
|
||||
do {
|
||||
if (tile_element_get_type(mapElement2) == TILE_ELEMENT_TYPE_PATH && mapElement2->base_height == z) {
|
||||
if (tile_element_get_type(tileElement2) == TILE_ELEMENT_TYPE_PATH && tileElement2->base_height == z) {
|
||||
gGameCommandErrorTitle = STR_CANT_REMOVE_FOOTPATH_FROM_HERE;
|
||||
footpath_remove(x, y, z, 1);
|
||||
break;
|
||||
}
|
||||
} while (!tile_element_is_last_for_tile(mapElement2++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement2++));
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* rct2: 0x006A61AB
|
||||
*/
|
||||
static void viewport_interaction_remove_footpath_item(rct_tile_element *mapElement, sint32 x, sint32 y)
|
||||
static void viewport_interaction_remove_footpath_item(rct_tile_element *tileElement, sint32 x, sint32 y)
|
||||
{
|
||||
sint32 type;
|
||||
|
||||
type = mapElement->properties.path.type >> 4;
|
||||
if (mapElement->type & 1)
|
||||
type = tileElement->properties.path.type >> 4;
|
||||
if (tileElement->type & 1)
|
||||
type |= 0x80;
|
||||
|
||||
gGameCommandErrorTitle = STR_CANT_REMOVE_THIS;
|
||||
game_do_command(
|
||||
x,
|
||||
((mapElement->properties.path.type & 7) << 8) | 1,
|
||||
((tileElement->properties.path.type & 7) << 8) | 1,
|
||||
y,
|
||||
(type << 8) | mapElement->base_height,
|
||||
(type << 8) | tileElement->base_height,
|
||||
GAME_COMMAND_PLACE_PATH,
|
||||
0,
|
||||
0
|
||||
|
@ -475,10 +475,10 @@ static void viewport_interaction_remove_footpath_item(rct_tile_element *mapEleme
|
|||
*
|
||||
* rct2: 0x00666C0E
|
||||
*/
|
||||
void viewport_interaction_remove_park_entrance(rct_tile_element *mapElement, sint32 x, sint32 y)
|
||||
void viewport_interaction_remove_park_entrance(rct_tile_element *tileElement, sint32 x, sint32 y)
|
||||
{
|
||||
sint32 rotation = tile_element_get_direction_with_offset(mapElement, 1);
|
||||
switch (mapElement->properties.entrance.index & 0x0F) {
|
||||
sint32 rotation = tile_element_get_direction_with_offset(tileElement, 1);
|
||||
switch (tileElement->properties.entrance.index & 0x0F) {
|
||||
case 1:
|
||||
x += TileDirectionDelta[rotation].x;
|
||||
y += TileDirectionDelta[rotation].y;
|
||||
|
@ -489,25 +489,25 @@ void viewport_interaction_remove_park_entrance(rct_tile_element *mapElement, sin
|
|||
break;
|
||||
}
|
||||
gGameCommandErrorTitle = STR_CANT_REMOVE_THIS;
|
||||
game_do_command(x, GAME_COMMAND_FLAG_APPLY, y, mapElement->base_height / 2, GAME_COMMAND_REMOVE_PARK_ENTRANCE, 0, 0);
|
||||
game_do_command(x, GAME_COMMAND_FLAG_APPLY, y, tileElement->base_height / 2, GAME_COMMAND_REMOVE_PARK_ENTRANCE, 0, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* rct2: 0x006E57A9
|
||||
*/
|
||||
static void viewport_interaction_remove_park_wall(rct_tile_element *mapElement, sint32 x, sint32 y)
|
||||
static void viewport_interaction_remove_park_wall(rct_tile_element *tileElement, sint32 x, sint32 y)
|
||||
{
|
||||
rct_scenery_entry *sceneryEntry = get_wall_entry(mapElement->properties.wall.type);
|
||||
rct_scenery_entry *sceneryEntry = get_wall_entry(tileElement->properties.wall.type);
|
||||
if (sceneryEntry->wall.scrolling_mode != 0xFF){
|
||||
context_open_detail_window(WD_SIGN_SMALL, mapElement->properties.wall.banner_index);
|
||||
context_open_detail_window(WD_SIGN_SMALL, tileElement->properties.wall.banner_index);
|
||||
} else {
|
||||
gGameCommandErrorTitle = STR_CANT_REMOVE_THIS;
|
||||
game_do_command(
|
||||
x,
|
||||
GAME_COMMAND_FLAG_APPLY,
|
||||
y,
|
||||
tile_element_get_direction(mapElement) | (mapElement->base_height << 8),
|
||||
tile_element_get_direction(tileElement) | (tileElement->base_height << 8),
|
||||
GAME_COMMAND_REMOVE_WALL,
|
||||
0,
|
||||
0
|
||||
|
@ -519,22 +519,22 @@ static void viewport_interaction_remove_park_wall(rct_tile_element *mapElement,
|
|||
*
|
||||
* rct2: 0x006B88DC
|
||||
*/
|
||||
static void viewport_interaction_remove_large_scenery(rct_tile_element *mapElement, sint32 x, sint32 y)
|
||||
static void viewport_interaction_remove_large_scenery(rct_tile_element *tileElement, sint32 x, sint32 y)
|
||||
{
|
||||
rct_scenery_entry *sceneryEntry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK);
|
||||
rct_scenery_entry *sceneryEntry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK);
|
||||
|
||||
if (sceneryEntry->large_scenery.scrolling_mode != 0xFF){
|
||||
sint32 id = (mapElement->type & 0xC0) |
|
||||
((mapElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) |
|
||||
((mapElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
|
||||
sint32 id = (tileElement->type & 0xC0) |
|
||||
((tileElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) |
|
||||
((tileElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
|
||||
context_open_detail_window(WD_SIGN, id);
|
||||
} else {
|
||||
gGameCommandErrorTitle = STR_CANT_REMOVE_THIS;
|
||||
game_do_command(
|
||||
x,
|
||||
1 | (tile_element_get_direction(mapElement) << 8),
|
||||
1 | (tile_element_get_direction(tileElement) << 8),
|
||||
y,
|
||||
mapElement->base_height | ((mapElement->properties.scenerymultiple.type >> 10) << 8),
|
||||
tileElement->base_height | ((tileElement->properties.scenerymultiple.type >> 10) << 8),
|
||||
GAME_COMMAND_REMOVE_LARGE_SCENERY,
|
||||
0,
|
||||
0
|
||||
|
@ -586,13 +586,13 @@ static rct_peep *viewport_interaction_get_closest_peep(sint32 x, sint32 y, sint3
|
|||
*
|
||||
* rct2: 0x0068A15E
|
||||
*/
|
||||
void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *direction, rct_tile_element **mapElement)
|
||||
void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *direction, rct_tile_element **tileElement)
|
||||
{
|
||||
sint16 my_x, my_y;
|
||||
sint32 interactionType;
|
||||
rct_tile_element *myMapElement;
|
||||
rct_tile_element *myTileElement;
|
||||
rct_viewport *viewport;
|
||||
get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_TERRAIN & VIEWPORT_INTERACTION_MASK_WATER, &my_x, &my_y, &interactionType, &myMapElement, &viewport);
|
||||
get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_TERRAIN & VIEWPORT_INTERACTION_MASK_WATER, &my_x, &my_y, &interactionType, &myTileElement, &viewport);
|
||||
|
||||
if (interactionType == VIEWPORT_INTERACTION_ITEM_NONE) {
|
||||
*x = LOCATION_NULL;
|
||||
|
@ -601,7 +601,7 @@ void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *di
|
|||
|
||||
sint16 originalZ = 0;
|
||||
if (interactionType == VIEWPORT_INTERACTION_ITEM_WATER) {
|
||||
originalZ = map_get_water_height(myMapElement) << 4;
|
||||
originalZ = map_get_water_height(myTileElement) << 4;
|
||||
}
|
||||
|
||||
LocationXY16 start_vp_pos = screen_coord_to_viewport_coord(viewport, screenX, screenY);
|
||||
|
@ -638,5 +638,5 @@ void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *di
|
|||
*x = map_pos.x & ~0x1F;
|
||||
*y = map_pos.y & ~0x1F;
|
||||
if (direction != NULL) *direction = myDirection;
|
||||
if (mapElement != NULL) *mapElement = myMapElement;
|
||||
if (tileElement != NULL) *tileElement = myTileElement;
|
||||
}
|
||||
|
|
|
@ -719,7 +719,7 @@ void window_game_bottom_toolbar_invalidate_news_item();
|
|||
void window_track_list_open(ride_list_item item);
|
||||
rct_window *window_ride_main_open(sint32 rideIndex);
|
||||
rct_window *window_ride_open_station(sint32 rideIndex, sint32 stationIndex);
|
||||
rct_window *window_ride_open_track(rct_tile_element *mapElement);
|
||||
rct_window *window_ride_open_track(rct_tile_element *tileElement);
|
||||
rct_window *window_ride_open_vehicle(rct_vehicle *vehicle);
|
||||
void window_ride_construct(rct_window *w);
|
||||
rct_window *window_ride_construction_open();
|
||||
|
|
|
@ -188,7 +188,7 @@ static paint_struct * sub_9819_c(paint_session * session, uint32 image_id, Locat
|
|||
ps->var_29 = 0;
|
||||
ps->map_x = session->MapPosition.x;
|
||||
ps->map_y = session->MapPosition.y;
|
||||
ps->mapElement = (rct_tile_element*)session->CurrentlyDrawnItem;
|
||||
ps->tileElement = (rct_tile_element*)session->CurrentlyDrawnItem;
|
||||
|
||||
return ps;
|
||||
}
|
||||
|
@ -847,7 +847,7 @@ extern "C"
|
|||
ps->var_29 = 0;
|
||||
ps->map_x = session->MapPosition.x;
|
||||
ps->map_y = session->MapPosition.y;
|
||||
ps->mapElement = (rct_tile_element*)session->CurrentlyDrawnItem;
|
||||
ps->tileElement = (rct_tile_element*)session->CurrentlyDrawnItem;
|
||||
|
||||
session->UnkF1AD28 = ps;
|
||||
|
||||
|
|
|
@ -81,7 +81,7 @@ struct paint_struct {
|
|||
uint16 pad_2A;
|
||||
uint16 map_x; // 0x2C
|
||||
uint16 map_y; // 0x2E
|
||||
rct_tile_element *mapElement; // 0x30 (or sprite pointer)
|
||||
rct_tile_element *tileElement; // 0x30 (or sprite pointer)
|
||||
};
|
||||
#ifdef PLATFORM_32BIT
|
||||
// TODO: drop packing from this when all rendering is done.
|
||||
|
|
|
@ -77,12 +77,12 @@ static const uint8 byte_98D8A4[] = {
|
|||
0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0
|
||||
};
|
||||
|
||||
void path_paint_pole_support(paint_session * session, rct_tile_element * mapElement, sint32 height, rct_footpath_entry * footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags);
|
||||
void path_paint_box_support(paint_session * session, rct_tile_element* mapElement, sint16 height, rct_footpath_entry* footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags);
|
||||
void path_paint_pole_support(paint_session * session, rct_tile_element * tileElement, sint32 height, rct_footpath_entry * footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags);
|
||||
void path_paint_box_support(paint_session * session, rct_tile_element* tileElement, sint16 height, rct_footpath_entry* footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags);
|
||||
|
||||
/* rct2: 0x006A5AE5 */
|
||||
static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* mapElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
|
||||
if (footpath_element_is_sloped(mapElement))
|
||||
static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* tileElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
|
||||
if (footpath_element_is_sloped(tileElement))
|
||||
height += 8;
|
||||
|
||||
uint32 imageId;
|
||||
|
@ -90,7 +90,7 @@ static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pa
|
|||
if (!(edges & (1 << 0))) {
|
||||
imageId = pathBitEntry->image + 1;
|
||||
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
imageId += 4;
|
||||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
@ -100,7 +100,7 @@ static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pa
|
|||
if (!(edges & (1 << 1))) {
|
||||
imageId = pathBitEntry->image + 2;
|
||||
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
imageId += 4;
|
||||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
@ -111,7 +111,7 @@ static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pa
|
|||
if (!(edges & (1 << 2))) {
|
||||
imageId = pathBitEntry->image + 3;
|
||||
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
imageId += 4;
|
||||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
@ -122,7 +122,7 @@ static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pa
|
|||
if (!(edges & (1 << 3))) {
|
||||
imageId = pathBitEntry->image + 4;
|
||||
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
imageId += 4;
|
||||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
@ -132,8 +132,8 @@ static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pa
|
|||
}
|
||||
|
||||
/* rct2: 0x006A5C94 */
|
||||
static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* mapElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
|
||||
if (footpath_element_is_sloped(mapElement))
|
||||
static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* tileElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
|
||||
if (footpath_element_is_sloped(tileElement))
|
||||
height += 8;
|
||||
|
||||
uint32 imageId;
|
||||
|
@ -143,12 +143,12 @@ static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* path
|
|||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
||||
if (!(mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
|
||||
if (!(tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
|
||||
imageId -= 4;
|
||||
|
||||
// Edges have been rotated around the rotation to check addition status
|
||||
// this will also need to be rotated.
|
||||
if (!(mapElement->properties.path.addition_status & ror8(0x3,(2 * get_current_rotation()))))
|
||||
if (!(tileElement->properties.path.addition_status & ror8(0x3,(2 * get_current_rotation()))))
|
||||
imageId += 8;
|
||||
}
|
||||
|
||||
|
@ -160,12 +160,12 @@ static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* path
|
|||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
||||
if (!(mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
|
||||
if (!(tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
|
||||
imageId -= 4;
|
||||
|
||||
// Edges have been rotated around the rotation to check addition status
|
||||
// this will also need to be rotated.
|
||||
if (!(mapElement->properties.path.addition_status & ror8(0xC, (2 * get_current_rotation()))))
|
||||
if (!(tileElement->properties.path.addition_status & ror8(0xC, (2 * get_current_rotation()))))
|
||||
imageId += 8;
|
||||
}
|
||||
|
||||
|
@ -178,12 +178,12 @@ static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* path
|
|||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
||||
if (!(mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
|
||||
if (!(tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
|
||||
imageId -= 4;
|
||||
|
||||
// Edges have been rotated around the rotation to check addition status
|
||||
// this will also need to be rotated.
|
||||
if (!(mapElement->properties.path.addition_status & ror8(0x30, (2 * get_current_rotation()))))
|
||||
if (!(tileElement->properties.path.addition_status & ror8(0x30, (2 * get_current_rotation()))))
|
||||
imageId += 8;
|
||||
}
|
||||
|
||||
|
@ -196,12 +196,12 @@ static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* path
|
|||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
||||
if (!(mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
|
||||
if (!(tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
|
||||
imageId -= 4;
|
||||
|
||||
// Edges have been rotated around the rotation to check addition status
|
||||
// this will also need to be rotated.
|
||||
if (!(mapElement->properties.path.addition_status & ror8(0xC0, (2 * get_current_rotation()))))
|
||||
if (!(tileElement->properties.path.addition_status & ror8(0xC0, (2 * get_current_rotation()))))
|
||||
imageId += 8;
|
||||
}
|
||||
|
||||
|
@ -211,13 +211,13 @@ static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* path
|
|||
}
|
||||
|
||||
/* rct2: 0x006A5E81 */
|
||||
static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* mapElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
|
||||
static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* tileElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
|
||||
uint32 imageId;
|
||||
|
||||
if (!(edges & (1 << 0))) {
|
||||
imageId = pathBitEntry->image + 1;
|
||||
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
imageId += 4;
|
||||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
@ -227,7 +227,7 @@ static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* p
|
|||
if (!(edges & (1 << 1))) {
|
||||
imageId = pathBitEntry->image + 2;
|
||||
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
imageId += 4;
|
||||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
@ -238,7 +238,7 @@ static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* p
|
|||
if (!(edges & (1 << 2))) {
|
||||
imageId = pathBitEntry->image + 3;
|
||||
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
imageId += 4;
|
||||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
@ -249,7 +249,7 @@ static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* p
|
|||
if (!(edges & (1 << 3))) {
|
||||
imageId = pathBitEntry->image + 4;
|
||||
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
|
||||
imageId += 4;
|
||||
|
||||
imageId |= pathBitImageFlags;
|
||||
|
@ -259,7 +259,7 @@ static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* p
|
|||
}
|
||||
|
||||
/* rct2: 0x006A6008 */
|
||||
static void path_bit_jumping_fountains_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* mapElement, sint32 height, uint8 edges, uint32 pathBitImageFlags, rct_drawpixelinfo* dpi) {
|
||||
static void path_bit_jumping_fountains_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* tileElement, sint32 height, uint8 edges, uint32 pathBitImageFlags, rct_drawpixelinfo* dpi) {
|
||||
if (dpi->zoom_level != 0)
|
||||
return;
|
||||
|
||||
|
@ -793,14 +793,14 @@ void path_paint(paint_session * session, uint8 direction, uint16 height, rct_til
|
|||
#endif
|
||||
}
|
||||
|
||||
void path_paint_pole_support(paint_session * session, rct_tile_element * mapElement, sint32 height, rct_footpath_entry * footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags)
|
||||
void path_paint_pole_support(paint_session * session, rct_tile_element * tileElement, sint32 height, rct_footpath_entry * footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags)
|
||||
{
|
||||
// Rol edges around rotation
|
||||
uint8 edges = ((mapElement->properties.path.edges << get_current_rotation()) & 0xF) |
|
||||
(((mapElement->properties.path.edges & 0xF) << get_current_rotation()) >> 4);
|
||||
uint8 edges = ((tileElement->properties.path.edges << get_current_rotation()) & 0xF) |
|
||||
(((tileElement->properties.path.edges & 0xF) << get_current_rotation()) >> 4);
|
||||
|
||||
uint8 corners = (((mapElement->properties.path.edges >> 4) << get_current_rotation()) & 0xF) |
|
||||
(((mapElement->properties.path.edges >> 4) << get_current_rotation()) >> 4);
|
||||
uint8 corners = (((tileElement->properties.path.edges >> 4) << get_current_rotation()) & 0xF) |
|
||||
(((tileElement->properties.path.edges >> 4) << get_current_rotation()) >> 4);
|
||||
|
||||
|
||||
LocationXY16 boundBoxOffset = {.x =stru_98D804[edges][0], .y = stru_98D804[edges][1]};
|
||||
|
@ -809,14 +809,14 @@ void path_paint_pole_support(paint_session * session, rct_tile_element * mapElem
|
|||
uint16 edi = edges | (corners << 4);
|
||||
|
||||
uint32 imageId;
|
||||
if (footpath_element_is_sloped(mapElement)) {
|
||||
imageId = ((mapElement->properties.path.type + get_current_rotation()) & 3) + 16;
|
||||
if (footpath_element_is_sloped(tileElement)) {
|
||||
imageId = ((tileElement->properties.path.type + get_current_rotation()) & 3) + 16;
|
||||
} else {
|
||||
imageId = byte_98D6E0[edi];
|
||||
}
|
||||
|
||||
imageId += footpathEntry->image;
|
||||
if (footpath_element_is_queue(mapElement)) {
|
||||
if (footpath_element_is_queue(tileElement)) {
|
||||
imageId += 51;
|
||||
}
|
||||
|
||||
|
@ -831,15 +831,15 @@ void path_paint_pole_support(paint_session * session, rct_tile_element * mapElem
|
|||
sub_98197C(session, imageId | imageFlags, 0, 0, boundBoxSize.x, boundBoxSize.y, 0, height, boundBoxOffset.x, boundBoxOffset.y, height + 1, get_current_rotation());
|
||||
} else {
|
||||
uint32 image_id;
|
||||
if (footpath_element_is_sloped(mapElement)) {
|
||||
image_id = ((mapElement->properties.path.type + get_current_rotation()) & 3) + footpathEntry->bridge_image + 51;
|
||||
if (footpath_element_is_sloped(tileElement)) {
|
||||
image_id = ((tileElement->properties.path.type + get_current_rotation()) & 3) + footpathEntry->bridge_image + 51;
|
||||
} else {
|
||||
image_id = byte_98D8A4[edges] + footpathEntry->bridge_image + 49;
|
||||
}
|
||||
|
||||
sub_98197C(session, image_id | imageFlags, 0, 0, boundBoxSize.x, boundBoxSize.y, 0, height, boundBoxOffset.x, boundBoxOffset.y, height + 1, get_current_rotation());
|
||||
|
||||
if (!footpath_element_is_queue(mapElement) && !(footpathEntry->flags & FOOTPATH_ENTRY_FLAG_HAS_PATH_BASE_SPRITE)) {
|
||||
if (!footpath_element_is_queue(tileElement) && !(footpathEntry->flags & FOOTPATH_ENTRY_FLAG_HAS_PATH_BASE_SPRITE)) {
|
||||
// don't draw
|
||||
} else {
|
||||
sub_98199C(session, imageId | imageFlags, 0, 0, boundBoxSize.x, boundBoxSize.y, 0, height, boundBoxOffset.x, boundBoxOffset.y, height + 1, get_current_rotation());
|
||||
|
@ -847,11 +847,11 @@ void path_paint_pole_support(paint_session * session, rct_tile_element * mapElem
|
|||
}
|
||||
|
||||
|
||||
sub_6A3F61(session, mapElement, edi, height, footpathEntry, imageFlags, sceneryImageFlags, hasFences);
|
||||
sub_6A3F61(session, tileElement, edi, height, footpathEntry, imageFlags, sceneryImageFlags, hasFences);
|
||||
|
||||
uint16 ax = 0;
|
||||
if (footpath_element_is_sloped(mapElement)) {
|
||||
ax = ((mapElement->properties.path.type + get_current_rotation()) & 0x3) + 1;
|
||||
if (footpath_element_is_sloped(tileElement)) {
|
||||
ax = ((tileElement->properties.path.type + get_current_rotation()) & 0x3) + 1;
|
||||
}
|
||||
|
||||
if (byte_98D8A4[edges] == 0) {
|
||||
|
@ -861,20 +861,20 @@ void path_paint_pole_support(paint_session * session, rct_tile_element * mapElem
|
|||
}
|
||||
|
||||
height += 32;
|
||||
if (footpath_element_is_sloped(mapElement)) {
|
||||
if (footpath_element_is_sloped(tileElement)) {
|
||||
height += 16;
|
||||
}
|
||||
|
||||
paint_util_set_general_support_height(session, height, 0x20);
|
||||
|
||||
if (footpath_element_is_queue(mapElement)
|
||||
|| (mapElement->properties.path.edges != 0xFF && hasFences)
|
||||
if (footpath_element_is_queue(tileElement)
|
||||
|| (tileElement->properties.path.edges != 0xFF && hasFences)
|
||||
) {
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
if (mapElement->properties.path.edges == 0xFF) {
|
||||
if (tileElement->properties.path.edges == 0xFF) {
|
||||
paint_util_set_segment_support_height(session, SEGMENT_C8 | SEGMENT_CC | SEGMENT_D0 | SEGMENT_D4, 0xFFFF, 0);
|
||||
return;
|
||||
}
|
||||
|
@ -898,11 +898,11 @@ void path_paint_pole_support(paint_session * session, rct_tile_element * mapElem
|
|||
}
|
||||
}
|
||||
|
||||
void path_paint_box_support(paint_session * session, rct_tile_element* mapElement, sint16 height, rct_footpath_entry* footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags)
|
||||
void path_paint_box_support(paint_session * session, rct_tile_element* tileElement, sint16 height, rct_footpath_entry* footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags)
|
||||
{
|
||||
// Rol edges around rotation
|
||||
uint8 edges = ((mapElement->properties.path.edges << get_current_rotation()) & 0xF) |
|
||||
(((mapElement->properties.path.edges & 0xF) << get_current_rotation()) >> 4);
|
||||
uint8 edges = ((tileElement->properties.path.edges << get_current_rotation()) & 0xF) |
|
||||
(((tileElement->properties.path.edges & 0xF) << get_current_rotation()) >> 4);
|
||||
|
||||
LocationXY16 boundBoxOffset = {
|
||||
.x = stru_98D804[edges][0],
|
||||
|
@ -914,14 +914,14 @@ void path_paint_box_support(paint_session * session, rct_tile_element* mapElemen
|
|||
.y = stru_98D804[edges][3]
|
||||
};
|
||||
|
||||
uint8 corners = (((mapElement->properties.path.edges >> 4) << get_current_rotation()) & 0xF) |
|
||||
(((mapElement->properties.path.edges >> 4) << get_current_rotation()) >> 4);
|
||||
uint8 corners = (((tileElement->properties.path.edges >> 4) << get_current_rotation()) & 0xF) |
|
||||
(((tileElement->properties.path.edges >> 4) << get_current_rotation()) >> 4);
|
||||
|
||||
uint16 edi = edges | (corners << 4);
|
||||
|
||||
uint32 imageId;
|
||||
if (footpath_element_is_sloped(mapElement)) {
|
||||
imageId = ((mapElement->properties.path.type + get_current_rotation()) & 3) + 16;
|
||||
if (footpath_element_is_sloped(tileElement)) {
|
||||
imageId = ((tileElement->properties.path.type + get_current_rotation()) & 3) + 16;
|
||||
}
|
||||
else {
|
||||
imageId = byte_98D6E0[edi];
|
||||
|
@ -929,7 +929,7 @@ void path_paint_box_support(paint_session * session, rct_tile_element* mapElemen
|
|||
|
||||
|
||||
imageId += footpathEntry->image;
|
||||
if (footpath_element_is_queue(mapElement)) {
|
||||
if (footpath_element_is_queue(tileElement)) {
|
||||
imageId += 51;
|
||||
}
|
||||
|
||||
|
@ -946,8 +946,8 @@ void path_paint_box_support(paint_session * session, rct_tile_element* mapElemen
|
|||
}
|
||||
else {
|
||||
uint32 bridgeImage;
|
||||
if (footpath_element_is_sloped(mapElement)) {
|
||||
bridgeImage = ((mapElement->properties.path.type + get_current_rotation()) & 3) + footpathEntry->bridge_image + 16;
|
||||
if (footpath_element_is_sloped(tileElement)) {
|
||||
bridgeImage = ((tileElement->properties.path.type + get_current_rotation()) & 3) + footpathEntry->bridge_image + 16;
|
||||
}
|
||||
else {
|
||||
bridgeImage = edges + footpathEntry->bridge_image;
|
||||
|
@ -956,15 +956,15 @@ void path_paint_box_support(paint_session * session, rct_tile_element* mapElemen
|
|||
|
||||
sub_98197C(session, bridgeImage | imageFlags, 0, 0, boundBoxSize.x, boundBoxSize.y, 0, height, boundBoxOffset.x, boundBoxOffset.y, height + 1, get_current_rotation());
|
||||
|
||||
if (footpath_element_is_queue(mapElement) || (footpathEntry->flags & FOOTPATH_ENTRY_FLAG_HAS_PATH_BASE_SPRITE)) {
|
||||
if (footpath_element_is_queue(tileElement) || (footpathEntry->flags & FOOTPATH_ENTRY_FLAG_HAS_PATH_BASE_SPRITE)) {
|
||||
sub_98199C(session, imageId | imageFlags, 0, 0, boundBoxSize.x, boundBoxSize.y, 0, height, boundBoxOffset.x, boundBoxOffset.y, height + 1, get_current_rotation());
|
||||
}
|
||||
}
|
||||
|
||||
sub_6A3F61(session, mapElement, edi, height, footpathEntry, imageFlags, sceneryImageFlags, hasFences); // TODO: arguments
|
||||
sub_6A3F61(session, tileElement, edi, height, footpathEntry, imageFlags, sceneryImageFlags, hasFences); // TODO: arguments
|
||||
|
||||
uint16 ax = 0;
|
||||
if (footpath_element_is_sloped(mapElement)) {
|
||||
if (footpath_element_is_sloped(tileElement)) {
|
||||
ax = 8;
|
||||
}
|
||||
|
||||
|
@ -982,21 +982,21 @@ void path_paint_box_support(paint_session * session, rct_tile_element* mapElemen
|
|||
}
|
||||
|
||||
height += 32;
|
||||
if (footpath_element_is_sloped(mapElement)) {
|
||||
if (footpath_element_is_sloped(tileElement)) {
|
||||
height += 16;
|
||||
}
|
||||
|
||||
paint_util_set_general_support_height(session, height, 0x20);
|
||||
|
||||
if (footpath_element_is_queue(mapElement)
|
||||
|| (mapElement->properties.path.edges != 0xFF && hasFences)
|
||||
if (footpath_element_is_queue(tileElement)
|
||||
|| (tileElement->properties.path.edges != 0xFF && hasFences)
|
||||
) {
|
||||
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
if (mapElement->properties.path.edges == 0xFF) {
|
||||
if (tileElement->properties.path.edges == 0xFF) {
|
||||
paint_util_set_segment_support_height(session, SEGMENT_C8 | SEGMENT_CC | SEGMENT_D0 | SEGMENT_D4, 0xFFFF, 0);
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -42,8 +42,8 @@ static const LocationXY16 lengths[] = {
|
|||
*
|
||||
* rct2: 0x006DFF47
|
||||
*/
|
||||
void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* mapElement) {
|
||||
//RCT2_CALLPROC_X(0x6DFF47, 0, 0, direction, height, (sint32)mapElement, 0, 0); return;
|
||||
void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* tileElement) {
|
||||
//RCT2_CALLPROC_X(0x6DFF47, 0, 0, direction, height, (sint32)tileElement, 0, 0); return;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_SCENERY;
|
||||
LocationXYZ16 boxlength;
|
||||
LocationXYZ16 boxoffset;
|
||||
|
@ -53,17 +53,17 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
|
|||
sint32 baseImageid = 0;
|
||||
const sint32 rotation = get_current_rotation();
|
||||
if (gTrackDesignSaveMode) {
|
||||
if (!track_design_save_contains_tile_element(mapElement)) {
|
||||
if (!track_design_save_contains_tile_element(tileElement)) {
|
||||
baseImageid = 0x21700000;
|
||||
}
|
||||
}
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_GHOST) {
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST) {
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_NONE;
|
||||
baseImageid = construction_markers[gConfigGeneral.construction_marker_colour];
|
||||
}
|
||||
uint32 dword_F64EB0 = baseImageid;
|
||||
|
||||
rct_scenery_entry *entry = get_small_scenery_entry(mapElement->properties.scenery.type);
|
||||
rct_scenery_entry *entry = get_small_scenery_entry(tileElement->properties.scenery.type);
|
||||
|
||||
if (entry == NULL)
|
||||
{
|
||||
|
@ -104,7 +104,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
|
|||
}
|
||||
} else {
|
||||
// 6DFFC2:
|
||||
uint8 ecx = (tile_element_get_scenery_quadrant(mapElement) + rotation) & 3;
|
||||
uint8 ecx = (tile_element_get_scenery_quadrant(tileElement) + rotation) & 3;
|
||||
x_offset = ScenerySubTileOffsets[ecx].x;
|
||||
y_offset = ScenerySubTileOffsets[ecx].y;
|
||||
boxoffset.x = x_offset;
|
||||
|
@ -116,10 +116,10 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
|
|||
boxlength.z = 128;
|
||||
}
|
||||
if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_CAN_WITHER) {
|
||||
if (mapElement->properties.scenery.age >= 40) {
|
||||
if (tileElement->properties.scenery.age >= 40) {
|
||||
baseImageid += 4;
|
||||
}
|
||||
if (mapElement->properties.scenery.age >= 55) {
|
||||
if (tileElement->properties.scenery.age >= 55) {
|
||||
baseImageid += 4;
|
||||
}
|
||||
}
|
||||
|
@ -127,12 +127,12 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
|
|||
{
|
||||
if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_HAS_SECONDARY_COLOUR)
|
||||
{
|
||||
baseImageid |= SPRITE_ID_PALETTE_COLOUR_2(scenery_small_get_primary_colour(mapElement),
|
||||
scenery_small_get_secondary_colour(mapElement));
|
||||
baseImageid |= SPRITE_ID_PALETTE_COLOUR_2(scenery_small_get_primary_colour(tileElement),
|
||||
scenery_small_get_secondary_colour(tileElement));
|
||||
}
|
||||
else
|
||||
{
|
||||
baseImageid |= SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(mapElement));
|
||||
baseImageid |= SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(tileElement));
|
||||
}
|
||||
}
|
||||
if (dword_F64EB0 != 0) {
|
||||
|
@ -146,7 +146,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
|
|||
if (dword_F64EB0 == 0) {
|
||||
// Draw translucent overlay:
|
||||
// TODO: Name palette entries
|
||||
sint32 image_id = (baseImageid & 0x7FFFF) + (GlassPaletteIds[scenery_small_get_primary_colour(mapElement)] << 19) + 0x40000004;
|
||||
sint32 image_id = (baseImageid & 0x7FFFF) + (GlassPaletteIds[scenery_small_get_primary_colour(tileElement)] << 19) + 0x40000004;
|
||||
sub_98199C(session, image_id, x_offset, y_offset, boxlength.x, boxlength.y, boxlength.z - 1, height, boxoffset.x, boxoffset.y, boxoffset.z, rotation);
|
||||
}
|
||||
}
|
||||
|
@ -233,7 +233,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
|
|||
if (!(entry->small_scenery.flags & SMALL_SCENERY_FLAG_COG)) {
|
||||
// 6E01F8:
|
||||
frame += ((session->SpritePosition.x / 4) + (session->SpritePosition.y / 4));
|
||||
frame += (mapElement->type & 0xC0) / 16;
|
||||
frame += (tileElement->type & 0xC0) / 16;
|
||||
}
|
||||
// 6E0222:
|
||||
uint16 delay = entry->small_scenery.animation_delay & 0xFF;
|
||||
|
@ -250,12 +250,12 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
|
|||
if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_HAS_PRIMARY_COLOUR)
|
||||
{
|
||||
if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_HAS_SECONDARY_COLOUR) {
|
||||
image_id |= SPRITE_ID_PALETTE_COLOUR_2(scenery_small_get_primary_colour(mapElement),
|
||||
scenery_small_get_secondary_colour(mapElement));
|
||||
image_id |= SPRITE_ID_PALETTE_COLOUR_2(scenery_small_get_primary_colour(tileElement),
|
||||
scenery_small_get_secondary_colour(tileElement));
|
||||
}
|
||||
else
|
||||
{
|
||||
image_id |= SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(mapElement));
|
||||
image_id |= SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(tileElement));
|
||||
}
|
||||
}
|
||||
if (dword_F64EB0 != 0) {
|
||||
|
@ -271,7 +271,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
|
|||
}
|
||||
}
|
||||
// 6E0556: Draw supports:
|
||||
if (scenery_small_get_supports_needed(mapElement)) {
|
||||
if (scenery_small_get_supports_needed(tileElement)) {
|
||||
if (!(entry->small_scenery.flags & SMALL_SCENERY_FLAG_NO_SUPPORTS)) {
|
||||
sint32 ax = 0;
|
||||
sint32 supportHeight = height;
|
||||
|
@ -282,7 +282,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
|
|||
uint32 supportImageColourFlags = IMAGE_TYPE_REMAP;
|
||||
if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_PAINT_SUPPORTS)
|
||||
{
|
||||
supportImageColourFlags = SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(mapElement));
|
||||
supportImageColourFlags = SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(tileElement));
|
||||
}
|
||||
if (dword_F64EB0 != 0) {
|
||||
supportImageColourFlags = dword_F64EB0;
|
||||
|
@ -310,7 +310,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
|
|||
}
|
||||
if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_VOFFSET_CENTRE) {
|
||||
// 6E075C:
|
||||
direction = (tile_element_get_scenery_quadrant(mapElement) + rotation) % 4;
|
||||
direction = (tile_element_get_scenery_quadrant(tileElement) + rotation) % 4;
|
||||
paint_util_set_segment_support_height(session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C8 | SEGMENT_CC, direction), height, 0x20);
|
||||
return;
|
||||
}
|
||||
|
@ -324,7 +324,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
|
|||
return;
|
||||
}
|
||||
if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_VOFFSET_CENTRE) {
|
||||
direction = (tile_element_get_scenery_quadrant(mapElement) + rotation) % 4;
|
||||
direction = (tile_element_get_scenery_quadrant(tileElement) + rotation) % 4;
|
||||
paint_util_set_segment_support_height(session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -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 *mapElement, uint32 dword_F4387C, rct_large_scenery_tile *tile)
|
||||
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)
|
||||
{
|
||||
if (tile->var_7 & 0x20) {
|
||||
return;
|
||||
|
@ -48,7 +48,7 @@ static void scenery_multiple_paint_supports(paint_session * session, uint8 direc
|
|||
|
||||
wooden_b_supports_paint_setup(session, (direction & 1), ax, supportHeight, supportImageColourFlags, NULL);
|
||||
|
||||
sint32 clearanceHeight = ceil2(mapElement->clearance_height * 8 + 15, 16);
|
||||
sint32 clearanceHeight = ceil2(tileElement->clearance_height * 8 + 15, 16);
|
||||
|
||||
if (tile->var_7 & 0x40) {
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, clearanceHeight, 0x20);
|
||||
|
@ -183,29 +183,29 @@ static const boundbox s98E3C4[] = {
|
|||
*
|
||||
* rct2: 0x006B7F0C
|
||||
*/
|
||||
void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement) {
|
||||
//RCT2_CALLPROC_X(0x6B7F0C, 0, 0, direction, height, (sint32)mapElement, 0, 0); return;
|
||||
void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement) {
|
||||
//RCT2_CALLPROC_X(0x6B7F0C, 0, 0, direction, height, (sint32)tileElement, 0, 0); return;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY;
|
||||
uint32 ebp = mapElement->properties.scenerymultiple.type >> 10;
|
||||
rct_scenery_entry *entry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & 0x3FF);
|
||||
uint32 ebp = tileElement->properties.scenerymultiple.type >> 10;
|
||||
rct_scenery_entry *entry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & 0x3FF);
|
||||
if (entry == NULL)
|
||||
return;
|
||||
|
||||
uint32 image_id = (ebp << 2) + entry->image + 4 + direction;
|
||||
rct_large_scenery_tile *tile = &entry->large_scenery.tiles[ebp];
|
||||
uint32 dword_F4387C = 0;
|
||||
image_id |= ((mapElement->properties.scenerymultiple.colour[0] & 0x1F) << 19) | ((mapElement->properties.scenerymultiple.colour[1] & 0x1F) << 24) | IMAGE_TYPE_REMAP | IMAGE_TYPE_REMAP_2_PLUS;
|
||||
image_id |= ((tileElement->properties.scenerymultiple.colour[0] & 0x1F) << 19) | ((tileElement->properties.scenerymultiple.colour[1] & 0x1F) << 24) | IMAGE_TYPE_REMAP | IMAGE_TYPE_REMAP_2_PLUS;
|
||||
LocationXYZ16 boxlength;
|
||||
LocationXYZ16 boxoffset;
|
||||
if (gTrackDesignSaveMode) {
|
||||
if (!track_design_save_contains_tile_element(mapElement)) {
|
||||
if (!track_design_save_contains_tile_element(tileElement)) {
|
||||
ebp = 0x21700000;
|
||||
image_id &= 0x7FFFF;
|
||||
dword_F4387C = ebp;
|
||||
image_id |= dword_F4387C;
|
||||
}
|
||||
}
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_GHOST) {
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST) {
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_NONE;
|
||||
ebp = construction_markers[gConfigGeneral.construction_marker_colour];
|
||||
image_id &= 0x7FFFF;
|
||||
|
@ -232,32 +232,32 @@ 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, mapElement, dword_F4387C, tile);
|
||||
scenery_multiple_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 al = ((mapElement->properties.surface.terrain >> 2) - 1) & 3;
|
||||
sint32 al = ((tileElement->properties.surface.terrain >> 2) - 1) & 3;
|
||||
if (al != direction) {
|
||||
scenery_multiple_paint_supports(session, direction, height, mapElement, dword_F4387C, tile);
|
||||
scenery_multiple_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, mapElement, dword_F4387C, tile);
|
||||
scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
|
||||
return;
|
||||
}
|
||||
// 6B8331:
|
||||
// Draw sign text:
|
||||
set_format_arg(0, uint32, 0);
|
||||
set_format_arg(4, uint32, 0);
|
||||
sint32 textColour = mapElement->properties.scenerymultiple.colour[1] & 0x1F;
|
||||
sint32 textColour = tileElement->properties.scenerymultiple.colour[1] & 0x1F;
|
||||
if (dword_F4387C) {
|
||||
textColour = COLOUR_GREY;
|
||||
}
|
||||
textColour = (textColour << 19) | IMAGE_TYPE_REMAP;
|
||||
uint32 bannerIndex = (mapElement->type & 0xC0) | ((mapElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) | ((mapElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
|
||||
uint32 bannerIndex = (tileElement->type & 0xC0) | ((tileElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) | ((tileElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
|
||||
rct_banner *banner = &gBanners[bannerIndex];
|
||||
rct_string_id stringId = banner->string_idx;
|
||||
if (banner->flags & BANNER_FLAG_LINKED_TO_RIDE) {
|
||||
|
@ -326,18 +326,18 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
|
|||
}
|
||||
rct_drawpixelinfo* dpi = session->Unk140E9A8;
|
||||
if (dpi->zoom_level > 0) {
|
||||
scenery_multiple_paint_supports(session, direction, height, mapElement, dword_F4387C, tile);
|
||||
scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
|
||||
return;
|
||||
}
|
||||
uint8 al = ((mapElement->properties.surface.terrain >> 2) - 1) & 3;
|
||||
uint8 al = ((tileElement->properties.surface.terrain >> 2) - 1) & 3;
|
||||
if (al != direction) {
|
||||
scenery_multiple_paint_supports(session, direction, height, mapElement, dword_F4387C, tile);
|
||||
scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
|
||||
return;
|
||||
}
|
||||
// Draw scrolling text:
|
||||
set_format_arg(0, uint32, 0);
|
||||
set_format_arg(4, uint32, 0);
|
||||
uint8 textColour = mapElement->properties.banner.unused & 0x1F;
|
||||
uint8 textColour = tileElement->properties.banner.unused & 0x1F;
|
||||
if (dword_F4387C) {
|
||||
textColour = COLOUR_GREY;
|
||||
}
|
||||
|
@ -346,7 +346,7 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
|
|||
}
|
||||
// 6B809A:
|
||||
set_format_arg(7, uint8, textColour);
|
||||
uint32 bannerIndex = (mapElement->type & 0xC0) | ((mapElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) | ((mapElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
|
||||
uint32 bannerIndex = (tileElement->type & 0xC0) | ((tileElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) | ((tileElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
|
||||
uint16 scrollMode = entry->large_scenery.scrolling_mode + ((direction + 1) & 0x3);
|
||||
rct_banner *banner = &gBanners[bannerIndex];
|
||||
set_format_arg(0, rct_string_id, banner->string_idx);
|
||||
|
@ -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, mapElement, dword_F4387C, tile);
|
||||
scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
|
||||
}
|
||||
|
|
|
@ -339,9 +339,9 @@ struct tile_descriptor
|
|||
corner_height corner_heights;
|
||||
};
|
||||
|
||||
static uint8 viewport_surface_paint_setup_get_relative_slope(rct_tile_element * mapElement, sint32 rotation)
|
||||
static uint8 viewport_surface_paint_setup_get_relative_slope(rct_tile_element * tileElement, sint32 rotation)
|
||||
{
|
||||
uint8 slope = mapElement->properties.surface.slope;
|
||||
uint8 slope = tileElement->properties.surface.slope;
|
||||
|
||||
uint16 di = (slope & 0x0F) << rotation;
|
||||
uint8 ebx = slope & 0x10;
|
||||
|
@ -988,18 +988,18 @@ static void viewport_surface_draw_water_side_bottom(paint_session * session, enu
|
|||
* @param height (dx)
|
||||
* @param tile_element (esi)
|
||||
*/
|
||||
void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element * mapElement)
|
||||
void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element * tileElement)
|
||||
{
|
||||
rct_drawpixelinfo * dpi = session->Unk140E9A8;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_TERRAIN;
|
||||
session->DidPassSurface = true;
|
||||
session->SurfaceElement = mapElement;
|
||||
session->SurfaceElement = tileElement;
|
||||
|
||||
uint16 zoomLevel = dpi->zoom_level;
|
||||
|
||||
const uint8 rotation = get_current_rotation();
|
||||
uint32 terrain_type = tile_element_get_terrain(mapElement);
|
||||
uint32 surfaceShape = viewport_surface_paint_setup_get_relative_slope(mapElement, rotation);
|
||||
uint32 terrain_type = tile_element_get_terrain(tileElement);
|
||||
uint32 surfaceShape = viewport_surface_paint_setup_get_relative_slope(tileElement, rotation);
|
||||
|
||||
LocationXY16 base = {
|
||||
.x = session->SpritePosition.x,
|
||||
|
@ -1008,7 +1008,7 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
|
|||
|
||||
corner_height ch = corner_heights[surfaceShape];
|
||||
tile_descriptor selfDescriptor = {
|
||||
.tile_element = mapElement,
|
||||
.tile_element = tileElement,
|
||||
.slope = surfaceShape,
|
||||
.terrain = terrain_type,
|
||||
.corner_heights = {
|
||||
|
@ -1075,11 +1075,11 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
|
|||
bool showGridlines = (gCurrentViewportFlags & VIEWPORT_FLAG_GRIDLINES);
|
||||
|
||||
sint32 branch = -1;
|
||||
if ((mapElement->properties.surface.terrain & 0xE0) == 0) {
|
||||
if (tile_element_get_direction(mapElement) == 0) {
|
||||
if ((tileElement->properties.surface.terrain & 0xE0) == 0) {
|
||||
if (tile_element_get_direction(tileElement) == 0) {
|
||||
if (zoomLevel == 0) {
|
||||
if ((gCurrentViewportFlags & (VIEWPORT_FLAG_HIDE_BASE | VIEWPORT_FLAG_UNDERGROUND_INSIDE)) == 0) {
|
||||
branch = mapElement->properties.surface.grass_length & 0x7;
|
||||
branch = tileElement->properties.surface.grass_length & 0x7;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1189,10 +1189,10 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
|
|||
|
||||
if (gCurrentViewportFlags & VIEWPORT_FLAG_LAND_OWNERSHIP) {
|
||||
// loc_660E9A:
|
||||
if (mapElement->properties.surface.ownership & OWNERSHIP_OWNED) {
|
||||
if (tileElement->properties.surface.ownership & OWNERSHIP_OWNED) {
|
||||
assert(surfaceShape < countof(byte_97B444));
|
||||
paint_attach_to_previous_ps(session, SPR_TERRAIN_SELECTION_SQUARE + byte_97B444[surfaceShape], 0, 0);
|
||||
} else if (mapElement->properties.surface.ownership & OWNERSHIP_AVAILABLE) {
|
||||
} else if (tileElement->properties.surface.ownership & OWNERSHIP_AVAILABLE) {
|
||||
LocationXY16 pos = session->MapPosition;
|
||||
paint_struct * backup = session->UnkF1AD28;
|
||||
sint32 height2 = (tile_element_height(pos.x + 16, pos.y + 16) & 0xFFFF) + 3;
|
||||
|
@ -1202,11 +1202,11 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
|
|||
}
|
||||
|
||||
if (gCurrentViewportFlags & VIEWPORT_FLAG_CONSTRUCTION_RIGHTS
|
||||
&& !(mapElement->properties.surface.ownership & OWNERSHIP_OWNED)) {
|
||||
if (mapElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED) {
|
||||
&& !(tileElement->properties.surface.ownership & OWNERSHIP_OWNED)) {
|
||||
if (tileElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED) {
|
||||
assert(surfaceShape < countof(byte_97B444));
|
||||
paint_attach_to_previous_ps(session, SPR_TERRAIN_SELECTION_DOTTED + byte_97B444[surfaceShape], 0, 0);
|
||||
} else if (mapElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_AVAILABLE) {
|
||||
} else if (tileElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_AVAILABLE) {
|
||||
paint_struct * backup = session->UnkF1AD28;
|
||||
LocationXY16 pos = session->MapPosition;
|
||||
sint32 height2 = tile_element_height(pos.x + 16, pos.y + 16) & 0xFFFF;
|
||||
|
@ -1254,9 +1254,9 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
|
|||
sint32 local_surfaceShape = surfaceShape;
|
||||
sint32 local_height = height;
|
||||
// Water tool
|
||||
if (map_get_water_height(mapElement) > 0)
|
||||
if (map_get_water_height(tileElement) > 0)
|
||||
{
|
||||
sint32 waterHeight = map_get_water_height(mapElement) * 16;
|
||||
sint32 waterHeight = map_get_water_height(tileElement) * 16;
|
||||
if (waterHeight > height) {
|
||||
local_height += 16;
|
||||
|
||||
|
@ -1330,8 +1330,8 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
|
|||
|
||||
if (!(gCurrentViewportFlags & VIEWPORT_FLAG_HIDE_VERTICAL)) {
|
||||
// loc_66122C:
|
||||
uint8 al_edgeStyle = mapElement->properties.surface.slope & 0xE0;
|
||||
uint8 di_type = mapElement->type & 0x80;
|
||||
uint8 al_edgeStyle = tileElement->properties.surface.slope & 0xE0;
|
||||
uint8 di_type = tileElement->type & 0x80;
|
||||
|
||||
uint32 eax = al_edgeStyle + di_type * 2;
|
||||
if (eax != 32 && eax != 0 && eax != 96 && eax != 64) {
|
||||
|
@ -1353,13 +1353,13 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
|
|||
memcpy(session->RightTunnels, backupRightTunnels, sizeof(tunnel_entry) * TUNNEL_MAX_COUNT);
|
||||
}
|
||||
|
||||
if (map_get_water_height(mapElement) > 0)
|
||||
if (map_get_water_height(tileElement) > 0)
|
||||
{
|
||||
// loc_6615A9: (water height)
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_WATER;
|
||||
|
||||
uint16 localHeight = height + 16;
|
||||
uint16 waterHeight = map_get_water_height(mapElement) * 16;
|
||||
uint16 waterHeight = map_get_water_height(tileElement) * 16;
|
||||
|
||||
if (!gTrackDesignSaveMode) {
|
||||
session->Unk141E9DC = waterHeight;
|
||||
|
@ -1375,8 +1375,8 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
|
|||
paint_attach_to_previous_ps(session, SPR_WATER_OVERLAY + image_offset, 0, 0);
|
||||
|
||||
// This wasn't in the original, but the code depended on globals that were only set in a different conditional
|
||||
uint8 al_edgeStyle = mapElement->properties.surface.slope & 0xE0;
|
||||
uint8 di_type = mapElement->type & 0x80;
|
||||
uint8 al_edgeStyle = tileElement->properties.surface.slope & 0xE0;
|
||||
uint8 di_type = tileElement->type & 0x80;
|
||||
|
||||
uint32 eax = al_edgeStyle + di_type * 2;
|
||||
assert(eax % 32 == 0);
|
||||
|
@ -1389,14 +1389,14 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
|
|||
}
|
||||
}
|
||||
|
||||
if ((mapElement->properties.surface.ownership & 0x0F) &&
|
||||
if ((tileElement->properties.surface.ownership & 0x0F) &&
|
||||
!gTrackDesignSaveMode
|
||||
) {
|
||||
// Owned land boundary fences
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_PARK;
|
||||
|
||||
registers regs = { 0 };
|
||||
regs.al = mapElement->properties.surface.ownership & 0x0F;
|
||||
regs.al = tileElement->properties.surface.ownership & 0x0F;
|
||||
regs.ax = regs.ax << rotation;
|
||||
regs.ah = regs.al >> 4;
|
||||
|
||||
|
|
|
@ -104,12 +104,12 @@ void tile_element_paint_setup(paint_session * session, sint32 x, sint32 y);
|
|||
|
||||
void entrance_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* tile_element);
|
||||
void banner_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* tile_element);
|
||||
void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement);
|
||||
void path_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement);
|
||||
void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* mapElement);
|
||||
void fence_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* mapElement);
|
||||
void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement);
|
||||
void track_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *mapElement);
|
||||
void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement);
|
||||
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 track_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *tileElement);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -801,7 +801,7 @@ void game_command_set_guest_name(sint32 * eax, sint32 * ebx, sint32 * ecx, sint3
|
|||
sint32 peep_pathfind_choose_direction(sint16 x, sint16 y, uint8 z, rct_peep * peep);
|
||||
void peep_reset_pathfind_goal(rct_peep * peep);
|
||||
|
||||
bool is_valid_path_z_and_direction(rct_tile_element * mapElement, sint32 currentZ, sint32 currentDirection);
|
||||
bool is_valid_path_z_and_direction(rct_tile_element * tileElement, sint32 currentZ, sint32 currentDirection);
|
||||
|
||||
#if defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
|
||||
#define PATHFIND_DEBUG 0 // Set to 0 to disable pathfinding debugging;
|
||||
|
|
|
@ -954,34 +954,34 @@ static uint8 staff_handyman_direction_to_nearest_litter(rct_peep * peep)
|
|||
|
||||
sint16 nextZ = ((peep->z + 8) & 0xFFF0) / 8;
|
||||
|
||||
rct_tile_element * mapElement = map_get_first_element_at(nextTile.x / 32, nextTile.y / 32);
|
||||
rct_tile_element * tileElement = map_get_first_element_at(nextTile.x / 32, nextTile.y / 32);
|
||||
|
||||
do
|
||||
{
|
||||
if (mapElement->base_height != nextZ)
|
||||
if (tileElement->base_height != nextZ)
|
||||
continue;
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE ||
|
||||
tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE ||
|
||||
tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
|
||||
{
|
||||
return 0xFF;
|
||||
}
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
nextTile.x = (peep->x & 0xFFE0) + TileDirectionDelta[nextDirection].x;
|
||||
nextTile.y = (peep->y & 0xFFE0) + TileDirectionDelta[nextDirection].y;
|
||||
|
||||
mapElement = map_get_first_element_at(nextTile.x / 32, nextTile.y / 32);
|
||||
tileElement = map_get_first_element_at(nextTile.x / 32, nextTile.y / 32);
|
||||
|
||||
do
|
||||
{
|
||||
if (mapElement->base_height != nextZ)
|
||||
if (tileElement->base_height != nextZ)
|
||||
continue;
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE ||
|
||||
tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE ||
|
||||
tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
|
||||
{
|
||||
return 0xFF;
|
||||
}
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
return nextDirection;
|
||||
}
|
||||
|
@ -996,17 +996,17 @@ static uint8 staff_handyman_direction_to_uncut_grass(rct_peep * peep, uint8 vali
|
|||
if (!(peep->next_var_29 & 0x18))
|
||||
{
|
||||
|
||||
rct_tile_element * mapElement = map_get_surface_element_at(peep->next_x / 32, peep->next_y / 32);
|
||||
rct_tile_element * tileElement = map_get_surface_element_at(peep->next_x / 32, peep->next_y / 32);
|
||||
|
||||
if (peep->next_z != mapElement->base_height)
|
||||
if (peep->next_z != tileElement->base_height)
|
||||
return 0xFF;
|
||||
|
||||
if (peep->next_var_29 & 0x4)
|
||||
{
|
||||
if ((mapElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK) != byte_98D800[peep->next_var_29 & 0x3])
|
||||
if ((tileElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK) != byte_98D800[peep->next_var_29 & 0x3])
|
||||
return 0xFF;
|
||||
}
|
||||
else if ((mapElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK) != 0)
|
||||
else if ((tileElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK) != 0)
|
||||
return 0xFF;
|
||||
}
|
||||
|
||||
|
@ -1026,15 +1026,15 @@ static uint8 staff_handyman_direction_to_uncut_grass(rct_peep * peep, uint8 vali
|
|||
if (chosenTile.x > 0x1FFF || chosenTile.y > 0x1FFF)
|
||||
continue;
|
||||
|
||||
rct_tile_element * mapElement = map_get_surface_element_at(chosenTile.x / 32, chosenTile.y / 32);
|
||||
rct_tile_element * tileElement = map_get_surface_element_at(chosenTile.x / 32, chosenTile.y / 32);
|
||||
|
||||
if (tile_element_get_terrain(mapElement) != 0)
|
||||
if (tile_element_get_terrain(tileElement) != 0)
|
||||
continue;
|
||||
|
||||
if (abs(mapElement->base_height - peep->next_z) > 2)
|
||||
if (abs(tileElement->base_height - peep->next_z) > 2)
|
||||
continue;
|
||||
|
||||
if ((mapElement->properties.surface.grass_length & 0x7) < GRASS_LENGTH_CLEAR_1)
|
||||
if ((tileElement->properties.surface.grass_length & 0x7) < GRASS_LENGTH_CLEAR_1)
|
||||
continue;
|
||||
|
||||
return chosenDirection;
|
||||
|
@ -1100,12 +1100,12 @@ static sint32 staff_path_finding_handyman(rct_peep * peep)
|
|||
}
|
||||
else
|
||||
{
|
||||
rct_tile_element * mapElement = map_get_path_element_at(peep->next_x / 32, peep->next_y / 32, peep->next_z);
|
||||
rct_tile_element * tileElement = map_get_path_element_at(peep->next_x / 32, peep->next_y / 32, peep->next_z);
|
||||
|
||||
if (mapElement == NULL)
|
||||
if (tileElement == NULL)
|
||||
return 1;
|
||||
|
||||
uint8 pathDirections = (mapElement->properties.path.edges & validDirections) & 0xF;
|
||||
uint8 pathDirections = (tileElement->properties.path.edges & validDirections) & 0xF;
|
||||
if (pathDirections == 0)
|
||||
{
|
||||
direction = staff_handyman_direction_rand_surface(peep, validDirections);
|
||||
|
@ -1328,22 +1328,22 @@ static uint8 staff_mechanic_direction_path(rct_peep * peep, uint8 validDirection
|
|||
|
||||
// Find the exit/entrance tile_element
|
||||
bool entranceFound = false;
|
||||
rct_tile_element * mapElement = map_get_first_element_at(chosenTile.x / 32, chosenTile.y / 32);
|
||||
rct_tile_element * tileElement = map_get_first_element_at(chosenTile.x / 32, chosenTile.y / 32);
|
||||
do
|
||||
{
|
||||
if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
|
||||
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
|
||||
continue;
|
||||
|
||||
if (mapElement->base_height != z)
|
||||
if (tileElement->base_height != z)
|
||||
continue;
|
||||
|
||||
if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE &&
|
||||
mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT)
|
||||
if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE &&
|
||||
tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT)
|
||||
continue;
|
||||
|
||||
entranceFound = true;
|
||||
break;
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
if (entranceFound == false)
|
||||
{
|
||||
|
|
|
@ -215,7 +215,7 @@ public:
|
|||
ImportRides();
|
||||
ImportRideMeasurements();
|
||||
ImportSprites();
|
||||
ImportMapElements();
|
||||
ImportTileElements();
|
||||
ImportMapAnimations();
|
||||
ImportPeepSpawns();
|
||||
ImportFinance();
|
||||
|
@ -452,34 +452,34 @@ private:
|
|||
{
|
||||
size_t maxTiles = 128 * 128;
|
||||
size_t tileIndex = 0;
|
||||
rct_tile_element * mapElement = _s4.tile_elements;
|
||||
rct_tile_element * tileElement = _s4.tile_elements;
|
||||
|
||||
while (tileIndex < maxTiles)
|
||||
{
|
||||
switch (tile_element_get_type(mapElement)) {
|
||||
switch (tile_element_get_type(tileElement)) {
|
||||
case TILE_ELEMENT_TYPE_PATH:
|
||||
{
|
||||
uint8 pathColour = tile_element_get_direction(mapElement);
|
||||
uint8 pathType = (mapElement->properties.path.type & 0xF0) >> 4;
|
||||
uint8 pathColour = tile_element_get_direction(tileElement);
|
||||
uint8 pathType = (tileElement->properties.path.type & 0xF0) >> 4;
|
||||
|
||||
pathType = (pathType << 2) | pathColour;
|
||||
uint8 pathAdditionsType = mapElement->properties.path.additions & 0x0F;
|
||||
uint8 pathAdditionsType = tileElement->properties.path.additions & 0x0F;
|
||||
|
||||
AddEntryForPath(pathType);
|
||||
AddEntryForPathAddition(pathAdditionsType);
|
||||
break;
|
||||
}
|
||||
case TILE_ELEMENT_TYPE_SCENERY:
|
||||
AddEntryForSmallScenery(mapElement->properties.scenery.type);
|
||||
AddEntryForSmallScenery(tileElement->properties.scenery.type);
|
||||
break;
|
||||
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
|
||||
AddEntryForLargeScenery(mapElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK);
|
||||
AddEntryForLargeScenery(tileElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK);
|
||||
break;
|
||||
case TILE_ELEMENT_TYPE_WALL:
|
||||
{
|
||||
uint8 var_05 = mapElement->properties.wall.colour_3;
|
||||
uint16 var_06 = mapElement->properties.wall.colour_1 |
|
||||
(mapElement->properties.wall.animation << 8);
|
||||
uint8 var_05 = tileElement->properties.wall.colour_3;
|
||||
uint16 var_06 = tileElement->properties.wall.colour_1 |
|
||||
(tileElement->properties.wall.animation << 8);
|
||||
|
||||
for (sint32 edge = 0; edge < 4; edge++)
|
||||
{
|
||||
|
@ -495,7 +495,7 @@ private:
|
|||
}
|
||||
}
|
||||
|
||||
if (tile_element_is_last_for_tile(mapElement++))
|
||||
if (tile_element_is_last_for_tile(tileElement++))
|
||||
{
|
||||
tileIndex++;
|
||||
}
|
||||
|
@ -1869,18 +1869,18 @@ private:
|
|||
}
|
||||
}
|
||||
|
||||
void ImportMapElements()
|
||||
void ImportTileElements()
|
||||
{
|
||||
Memory::Copy(gMapElements, _s4.tile_elements, RCT1_MAX_TILE_ELEMENTS * sizeof(rct_tile_element));
|
||||
Memory::Copy(gTileElements, _s4.tile_elements, RCT1_MAX_TILE_ELEMENTS * sizeof(rct_tile_element));
|
||||
ClearExtraTileEntries();
|
||||
FixSceneryColours();
|
||||
FixMapElementZ();
|
||||
FixTileElementZ();
|
||||
FixPaths();
|
||||
FixWalls();
|
||||
FixBanners();
|
||||
FixTerrain();
|
||||
FixEntrancePositions();
|
||||
FixMapElementEntryTypes();
|
||||
FixTileElementEntryTypes();
|
||||
}
|
||||
|
||||
void ImportResearch()
|
||||
|
@ -2217,17 +2217,17 @@ private:
|
|||
void ClearExtraTileEntries()
|
||||
{
|
||||
// Reset the map tile pointers
|
||||
Memory::Set(gMapElementTilePointers, 0, sizeof(rct_tile_element*) * MAX_TILE_TILE_ELEMENT_POINTERS);
|
||||
Memory::Set(gTileElementTilePointers, 0, sizeof(rct_tile_element*) * MAX_TILE_TILE_ELEMENT_POINTERS);
|
||||
|
||||
// Get the first free map element
|
||||
rct_tile_element * nextFreeMapElement = gMapElements;
|
||||
rct_tile_element * nextFreeTileElement = gTileElements;
|
||||
for (size_t i = 0; i < RCT1_MAX_MAP_SIZE * RCT1_MAX_MAP_SIZE; i++)
|
||||
{
|
||||
while (!tile_element_is_last_for_tile(nextFreeMapElement++));
|
||||
while (!tile_element_is_last_for_tile(nextFreeTileElement++));
|
||||
}
|
||||
|
||||
rct_tile_element * mapElement = gMapElements;
|
||||
rct_tile_element * * tilePointer = gMapElementTilePointers;
|
||||
rct_tile_element * tileElement = gTileElements;
|
||||
rct_tile_element * * tilePointer = gTileElementTilePointers;
|
||||
|
||||
// 128 rows of map data from RCT1 map
|
||||
for (sint32 x = 0; x < RCT1_MAX_MAP_SIZE; x++)
|
||||
|
@ -2235,160 +2235,160 @@ private:
|
|||
// Assign the first half of this row
|
||||
for (sint32 y = 0; y < RCT1_MAX_MAP_SIZE; y++)
|
||||
{
|
||||
*tilePointer++ = mapElement;
|
||||
while (!tile_element_is_last_for_tile(mapElement++));
|
||||
*tilePointer++ = tileElement;
|
||||
while (!tile_element_is_last_for_tile(tileElement++));
|
||||
}
|
||||
|
||||
// Fill the rest of the row with blank tiles
|
||||
for (sint32 y = 0; y < RCT1_MAX_MAP_SIZE; y++)
|
||||
{
|
||||
nextFreeMapElement->type = TILE_ELEMENT_TYPE_SURFACE;
|
||||
nextFreeMapElement->flags = TILE_ELEMENT_FLAG_LAST_TILE;
|
||||
nextFreeMapElement->base_height = 2;
|
||||
nextFreeMapElement->clearance_height = 0;
|
||||
nextFreeMapElement->properties.surface.slope = 0;
|
||||
nextFreeMapElement->properties.surface.terrain = 0;
|
||||
nextFreeMapElement->properties.surface.grass_length = GRASS_LENGTH_CLEAR_0;
|
||||
nextFreeMapElement->properties.surface.ownership = 0;
|
||||
*tilePointer++ = nextFreeMapElement++;
|
||||
nextFreeTileElement->type = TILE_ELEMENT_TYPE_SURFACE;
|
||||
nextFreeTileElement->flags = TILE_ELEMENT_FLAG_LAST_TILE;
|
||||
nextFreeTileElement->base_height = 2;
|
||||
nextFreeTileElement->clearance_height = 0;
|
||||
nextFreeTileElement->properties.surface.slope = 0;
|
||||
nextFreeTileElement->properties.surface.terrain = 0;
|
||||
nextFreeTileElement->properties.surface.grass_length = GRASS_LENGTH_CLEAR_0;
|
||||
nextFreeTileElement->properties.surface.ownership = 0;
|
||||
*tilePointer++ = nextFreeTileElement++;
|
||||
}
|
||||
}
|
||||
|
||||
// 128 extra rows left to fill with blank tiles
|
||||
for (sint32 y = 0; y < 128 * 256; y++)
|
||||
{
|
||||
nextFreeMapElement->type = TILE_ELEMENT_TYPE_SURFACE;
|
||||
nextFreeMapElement->flags = TILE_ELEMENT_FLAG_LAST_TILE;
|
||||
nextFreeMapElement->base_height = 2;
|
||||
nextFreeMapElement->clearance_height = 0;
|
||||
nextFreeMapElement->properties.surface.slope = 0;
|
||||
nextFreeMapElement->properties.surface.terrain = 0;
|
||||
nextFreeMapElement->properties.surface.grass_length = GRASS_LENGTH_CLEAR_0;
|
||||
nextFreeMapElement->properties.surface.ownership = 0;
|
||||
*tilePointer++ = nextFreeMapElement++;
|
||||
nextFreeTileElement->type = TILE_ELEMENT_TYPE_SURFACE;
|
||||
nextFreeTileElement->flags = TILE_ELEMENT_FLAG_LAST_TILE;
|
||||
nextFreeTileElement->base_height = 2;
|
||||
nextFreeTileElement->clearance_height = 0;
|
||||
nextFreeTileElement->properties.surface.slope = 0;
|
||||
nextFreeTileElement->properties.surface.terrain = 0;
|
||||
nextFreeTileElement->properties.surface.grass_length = GRASS_LENGTH_CLEAR_0;
|
||||
nextFreeTileElement->properties.surface.ownership = 0;
|
||||
*tilePointer++ = nextFreeTileElement++;
|
||||
}
|
||||
|
||||
gNextFreeMapElement = nextFreeMapElement;
|
||||
gNextFreeTileElement = nextFreeTileElement;
|
||||
}
|
||||
|
||||
void FixSceneryColours()
|
||||
{
|
||||
colour_t colour;
|
||||
rct_tile_element * mapElement = gMapElements;
|
||||
while (mapElement < gNextFreeMapElement)
|
||||
rct_tile_element * tileElement = gTileElements;
|
||||
while (tileElement < gNextFreeTileElement)
|
||||
{
|
||||
if (mapElement->base_height != 255)
|
||||
if (tileElement->base_height != 255)
|
||||
{
|
||||
switch (tile_element_get_type(mapElement)) {
|
||||
switch (tile_element_get_type(tileElement)) {
|
||||
case TILE_ELEMENT_TYPE_SCENERY:
|
||||
colour = RCT1::GetColour(scenery_small_get_primary_colour(mapElement));
|
||||
scenery_small_set_primary_colour(mapElement, colour);
|
||||
colour = RCT1::GetColour(scenery_small_get_primary_colour(tileElement));
|
||||
scenery_small_set_primary_colour(tileElement, colour);
|
||||
|
||||
// Copied from [rct2: 0x006A2956]
|
||||
switch (mapElement->properties.scenery.type) {
|
||||
switch (tileElement->properties.scenery.type) {
|
||||
case 157: // TGE1 (Geometric Sculpture)
|
||||
case 162: // TGE2 (Geometric Sculpture)
|
||||
case 168: // TGE3 (Geometric Sculpture)
|
||||
case 170: // TGE4 (Geometric Sculpture)
|
||||
case 171: // TGE5 (Geometric Sculpture)
|
||||
scenery_small_set_secondary_colour(mapElement, COLOUR_WHITE);
|
||||
scenery_small_set_secondary_colour(tileElement, COLOUR_WHITE);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case TILE_ELEMENT_TYPE_WALL:
|
||||
colour = ((mapElement->type & 0xC0) >> 3) |
|
||||
((mapElement->properties.wall.type & 0xE0) >> 5);
|
||||
colour = ((tileElement->type & 0xC0) >> 3) |
|
||||
((tileElement->properties.wall.type & 0xE0) >> 5);
|
||||
colour = RCT1::GetColour(colour);
|
||||
|
||||
mapElement->type &= 0x3F;
|
||||
mapElement->properties.wall.type &= 0x1F;
|
||||
mapElement->type |= (colour & 0x18) << 3;
|
||||
mapElement->properties.wall.type |= (colour & 7) << 5;
|
||||
tileElement->type &= 0x3F;
|
||||
tileElement->properties.wall.type &= 0x1F;
|
||||
tileElement->type |= (colour & 0x18) << 3;
|
||||
tileElement->properties.wall.type |= (colour & 7) << 5;
|
||||
break;
|
||||
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
|
||||
colour = RCT1::GetColour(mapElement->properties.scenerymultiple.colour[0] & 0x1F);
|
||||
mapElement->properties.scenerymultiple.colour[0] &= 0xE0;
|
||||
mapElement->properties.scenerymultiple.colour[0] |= colour;
|
||||
colour = RCT1::GetColour(tileElement->properties.scenerymultiple.colour[0] & 0x1F);
|
||||
tileElement->properties.scenerymultiple.colour[0] &= 0xE0;
|
||||
tileElement->properties.scenerymultiple.colour[0] |= colour;
|
||||
|
||||
colour = RCT1::GetColour(mapElement->properties.scenerymultiple.colour[1] & 0x1F);
|
||||
mapElement->properties.scenerymultiple.colour[1] &= 0xE0;
|
||||
mapElement->properties.scenerymultiple.colour[1] |= colour;
|
||||
colour = RCT1::GetColour(tileElement->properties.scenerymultiple.colour[1] & 0x1F);
|
||||
tileElement->properties.scenerymultiple.colour[1] &= 0xE0;
|
||||
tileElement->properties.scenerymultiple.colour[1] |= colour;
|
||||
break;
|
||||
}
|
||||
}
|
||||
mapElement++;
|
||||
tileElement++;
|
||||
}
|
||||
}
|
||||
|
||||
void FixMapElementZ()
|
||||
void FixTileElementZ()
|
||||
{
|
||||
rct_tile_element * mapElement = gMapElements;
|
||||
while (mapElement < gNextFreeMapElement)
|
||||
rct_tile_element * tileElement = gTileElements;
|
||||
while (tileElement < gNextFreeTileElement)
|
||||
{
|
||||
if (mapElement->base_height != 255)
|
||||
if (tileElement->base_height != 255)
|
||||
{
|
||||
mapElement->base_height /= 2;
|
||||
mapElement->clearance_height /= 2;
|
||||
tileElement->base_height /= 2;
|
||||
tileElement->clearance_height /= 2;
|
||||
}
|
||||
mapElement++;
|
||||
tileElement++;
|
||||
}
|
||||
gMapBaseZ = 7;
|
||||
}
|
||||
|
||||
void FixPaths()
|
||||
{
|
||||
rct_tile_element * mapElement = gMapElements;
|
||||
while (mapElement < gNextFreeMapElement)
|
||||
rct_tile_element * tileElement = gTileElements;
|
||||
while (tileElement < gNextFreeTileElement)
|
||||
{
|
||||
switch (tile_element_get_type(mapElement)) {
|
||||
switch (tile_element_get_type(tileElement)) {
|
||||
case TILE_ELEMENT_TYPE_PATH:
|
||||
{
|
||||
// Type
|
||||
uint8 pathColour = mapElement->type & 3;
|
||||
uint8 pathType = (mapElement->properties.path.type & 0xF0) >> 4;
|
||||
uint8 pathColour = tileElement->type & 3;
|
||||
uint8 pathType = (tileElement->properties.path.type & 0xF0) >> 4;
|
||||
|
||||
pathType = (pathType << 2) | pathColour;
|
||||
uint8 entryIndex = _pathTypeToEntryMap[pathType];
|
||||
|
||||
mapElement->type &= 0xFC;
|
||||
mapElement->flags &= ~0x60;
|
||||
mapElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
|
||||
mapElement->properties.path.type &= 0x0F;
|
||||
footpath_scenery_set_is_ghost(mapElement, false);
|
||||
tileElement->type &= 0xFC;
|
||||
tileElement->flags &= ~0x60;
|
||||
tileElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
|
||||
tileElement->properties.path.type &= 0x0F;
|
||||
footpath_scenery_set_is_ghost(tileElement, false);
|
||||
if (RCT1::PathIsQueue(pathType))
|
||||
{
|
||||
mapElement->type |= 1;
|
||||
tileElement->type |= 1;
|
||||
}
|
||||
mapElement->properties.path.type |= entryIndex << 4;
|
||||
tileElement->properties.path.type |= entryIndex << 4;
|
||||
|
||||
// Additions
|
||||
uint8 additionType = footpath_element_get_path_scenery(mapElement);
|
||||
uint8 additionType = footpath_element_get_path_scenery(tileElement);
|
||||
if (additionType != RCT1_PATH_ADDITION_NONE)
|
||||
{
|
||||
uint8 normalisedType = RCT1::NormalisePathAddition(additionType);
|
||||
entryIndex = _pathAdditionTypeToEntryMap[normalisedType];
|
||||
if (additionType != normalisedType)
|
||||
{
|
||||
mapElement->flags |= TILE_ELEMENT_FLAG_BROKEN;
|
||||
tileElement->flags |= TILE_ELEMENT_FLAG_BROKEN;
|
||||
}
|
||||
footpath_element_set_path_scenery(mapElement, entryIndex + 1);
|
||||
footpath_element_set_path_scenery(tileElement, entryIndex + 1);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case TILE_ELEMENT_TYPE_ENTRANCE:
|
||||
if (mapElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE)
|
||||
if (tileElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE)
|
||||
{
|
||||
uint8 pathType = mapElement->properties.entrance.path_type;
|
||||
uint8 pathType = tileElement->properties.entrance.path_type;
|
||||
if (pathType == 0)
|
||||
{
|
||||
pathType = RCT1_FOOTPATH_TYPE_TARMAC_GRAY;
|
||||
}
|
||||
uint8 entryIndex = _pathTypeToEntryMap[pathType];
|
||||
mapElement->properties.entrance.path_type = entryIndex & 0x7F;
|
||||
tileElement->properties.entrance.path_type = entryIndex & 0x7F;
|
||||
}
|
||||
break;
|
||||
}
|
||||
mapElement++;
|
||||
tileElement++;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2403,17 +2403,17 @@ private:
|
|||
{
|
||||
for (sint32 y = 0; y < RCT1_MAX_MAP_SIZE; y++)
|
||||
{
|
||||
rct_tile_element * mapElement = map_get_first_element_at(x, y);
|
||||
rct_tile_element * tileElement = map_get_first_element_at(x, y);
|
||||
do
|
||||
{
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_WALL)
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL)
|
||||
{
|
||||
rct_tile_element originalMapElement = *mapElement;
|
||||
tile_element_remove(mapElement);
|
||||
rct_tile_element originalTileElement = *tileElement;
|
||||
tile_element_remove(tileElement);
|
||||
|
||||
uint8 var_05 = originalMapElement.properties.wall.colour_3;
|
||||
uint16 var_06 = originalMapElement.properties.wall.colour_1 |
|
||||
(originalMapElement.properties.wall.animation << 8);
|
||||
uint8 var_05 = originalTileElement.properties.wall.colour_3;
|
||||
uint16 var_06 = originalTileElement.properties.wall.colour_1 |
|
||||
(originalTileElement.properties.wall.animation << 8);
|
||||
|
||||
for (sint32 edge = 0; edge < 4; edge++)
|
||||
{
|
||||
|
@ -2422,8 +2422,8 @@ private:
|
|||
if (typeB != 0x0F)
|
||||
{
|
||||
sint32 type = typeA | (typeB << 2);
|
||||
sint32 colourA = ((originalMapElement.type & 0xC0) >> 3) |
|
||||
(originalMapElement.properties.wall.type >> 5);
|
||||
sint32 colourA = ((originalTileElement.type & 0xC0) >> 3) |
|
||||
(originalTileElement.properties.wall.type >> 5);
|
||||
sint32 colourB = 0;
|
||||
sint32 colourC = 0;
|
||||
ConvertWall(&type, &colourA, &colourB, &colourC);
|
||||
|
@ -2435,7 +2435,7 @@ private:
|
|||
break;
|
||||
}
|
||||
}
|
||||
while (!tile_element_is_last_for_tile(mapElement++));
|
||||
while (!tile_element_is_last_for_tile(tileElement++));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2484,18 +2484,18 @@ private:
|
|||
{
|
||||
for (sint32 y = 0; y < RCT1_MAX_MAP_SIZE; y++)
|
||||
{
|
||||
rct_tile_element * mapElement = map_get_first_element_at(x, y);
|
||||
rct_tile_element * tileElement = map_get_first_element_at(x, y);
|
||||
do
|
||||
{
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_BANNER)
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_BANNER)
|
||||
{
|
||||
uint8 index = mapElement->properties.banner.index;
|
||||
uint8 index = tileElement->properties.banner.index;
|
||||
rct_banner * src = &_s4.banners[index];
|
||||
rct_banner * dst = &gBanners[index];
|
||||
ImportBanner(dst, src);
|
||||
}
|
||||
}
|
||||
while (!tile_element_is_last_for_tile(mapElement++));
|
||||
while (!tile_element_is_last_for_tile(tileElement++));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -2562,22 +2562,22 @@ private:
|
|||
}
|
||||
}
|
||||
|
||||
void FixMapElementEntryTypes()
|
||||
void FixTileElementEntryTypes()
|
||||
{
|
||||
tile_element_iterator it;
|
||||
tile_element_iterator_begin(&it);
|
||||
while (tile_element_iterator_next(&it))
|
||||
{
|
||||
rct_tile_element * mapElement = it.element;
|
||||
switch (tile_element_get_type(mapElement)) {
|
||||
rct_tile_element * tileElement = it.element;
|
||||
switch (tile_element_get_type(tileElement)) {
|
||||
case TILE_ELEMENT_TYPE_SCENERY:
|
||||
mapElement->properties.scenery.type = _smallSceneryTypeToEntryMap[mapElement->properties.scenery.type];
|
||||
tileElement->properties.scenery.type = _smallSceneryTypeToEntryMap[tileElement->properties.scenery.type];
|
||||
break;
|
||||
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
|
||||
{
|
||||
uint8 type = mapElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK;
|
||||
mapElement->properties.scenerymultiple.type &= ~TILE_ELEMENT_LARGE_TYPE_MASK;
|
||||
mapElement->properties.scenerymultiple.type |= _largeSceneryTypeToEntryMap[type];
|
||||
uint8 type = tileElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK;
|
||||
tileElement->properties.scenerymultiple.type &= ~TILE_ELEMENT_LARGE_TYPE_MASK;
|
||||
tileElement->properties.scenerymultiple.type |= _largeSceneryTypeToEntryMap[type];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -2673,16 +2673,16 @@ private:
|
|||
{
|
||||
for (sint32 y = 0; y < RCT1_MAX_MAP_SIZE; y++)
|
||||
{
|
||||
rct_tile_element * mapElement = map_get_first_element_at(x, y);
|
||||
rct_tile_element * tileElement = map_get_first_element_at(x, y);
|
||||
do
|
||||
{
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
|
||||
{
|
||||
// Lift hill tops are the only pieces present in RCT1 that can count as a block brake.
|
||||
if (!track_element_is_lift_hill(mapElement))
|
||||
if (!track_element_is_lift_hill(tileElement))
|
||||
continue;
|
||||
|
||||
uint8 trackType = mapElement->properties.track.type;
|
||||
uint8 trackType = tileElement->properties.track.type;
|
||||
switch (trackType) {
|
||||
case TRACK_ELEM_25_DEG_UP_TO_FLAT:
|
||||
case TRACK_ELEM_60_DEG_UP_TO_FLAT:
|
||||
|
@ -2693,12 +2693,12 @@ private:
|
|||
continue;
|
||||
}
|
||||
|
||||
uint8 rideIndex = mapElement->properties.track.ride_index;
|
||||
uint8 rideIndex = tileElement->properties.track.ride_index;
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
ride->num_block_brakes++;
|
||||
}
|
||||
}
|
||||
while (!tile_element_is_last_for_tile(mapElement++));
|
||||
while (!tile_element_is_last_for_tile(tileElement++));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -183,9 +183,9 @@ void S6Exporter::Export()
|
|||
_s6.scenario_srand_0 = gScenarioSrand0;
|
||||
_s6.scenario_srand_1 = gScenarioSrand1;
|
||||
|
||||
memcpy(_s6.tile_elements, gMapElements, sizeof(_s6.tile_elements));
|
||||
memcpy(_s6.tile_elements, gTileElements, sizeof(_s6.tile_elements));
|
||||
|
||||
_s6.next_free_tile_element_pointer_index = gNextFreeMapElementPointerIndex;
|
||||
_s6.next_free_tile_element_pointer_index = gNextFreeTileElementPointerIndex;
|
||||
// Sprites needs to be reset before they get used.
|
||||
// Might as well reset them in here to zero out the space and improve
|
||||
// compression ratios. Especially useful for multiplayer servers that
|
||||
|
|
|
@ -198,9 +198,9 @@ public:
|
|||
gScenarioSrand0 = _s6.scenario_srand_0;
|
||||
gScenarioSrand1 = _s6.scenario_srand_1;
|
||||
|
||||
memcpy(gMapElements, _s6.tile_elements, sizeof(_s6.tile_elements));
|
||||
memcpy(gTileElements, _s6.tile_elements, sizeof(_s6.tile_elements));
|
||||
|
||||
gNextFreeMapElementPointerIndex = _s6.next_free_tile_element_pointer_index;
|
||||
gNextFreeTileElementPointerIndex = _s6.next_free_tile_element_pointer_index;
|
||||
for (sint32 i = 0; i < RCT2_MAX_SPRITES; i++)
|
||||
{
|
||||
memcpy(get_sprite(i), &_s6.sprites[i], sizeof(rct_sprite));
|
||||
|
|
|
@ -57,13 +57,13 @@ void ride_update_station(Ride * ride, sint32 stationIndex)
|
|||
*/
|
||||
static void ride_update_station_blocksection(Ride * ride, sint32 stationIndex)
|
||||
{
|
||||
rct_tile_element * mapElement = ride_get_station_start_track_element(ride, stationIndex);
|
||||
rct_tile_element * tileElement = ride_get_station_start_track_element(ride, stationIndex);
|
||||
|
||||
if ((ride->status == RIDE_STATUS_CLOSED && ride->num_riders == 0) || (mapElement != nullptr && mapElement->flags & 0x20))
|
||||
if ((ride->status == RIDE_STATUS_CLOSED && ride->num_riders == 0) || (tileElement != nullptr && tileElement->flags & 0x20))
|
||||
{
|
||||
ride->station_depart[stationIndex] &= ~STATION_DEPART_FLAG;
|
||||
|
||||
if ((ride->station_depart[stationIndex] & STATION_DEPART_FLAG) || (mapElement != nullptr && tile_element_get_green_light(mapElement)))
|
||||
if ((ride->station_depart[stationIndex] & STATION_DEPART_FLAG) || (tileElement != nullptr && tile_element_get_green_light(tileElement)))
|
||||
ride_invalidate_station_start(ride, stationIndex, false);
|
||||
}
|
||||
else
|
||||
|
@ -73,7 +73,7 @@ static void ride_update_station_blocksection(Ride * ride, sint32 stationIndex)
|
|||
ride->station_depart[stationIndex] |= STATION_DEPART_FLAG;
|
||||
ride_invalidate_station_start(ride, stationIndex, true);
|
||||
}
|
||||
else if (mapElement != nullptr && tile_element_get_green_light(mapElement))
|
||||
else if (tileElement != nullptr && tile_element_get_green_light(tileElement))
|
||||
{
|
||||
ride_invalidate_station_start(ride, stationIndex, true);
|
||||
}
|
||||
|
@ -296,16 +296,16 @@ static void ride_invalidate_station_start(Ride * ride, sint32 stationIndex, bool
|
|||
{
|
||||
sint32 x = ride->station_starts[stationIndex].x * 32;
|
||||
sint32 y = ride->station_starts[stationIndex].y * 32;
|
||||
rct_tile_element * mapElement = ride_get_station_start_track_element(ride, stationIndex);
|
||||
rct_tile_element * tileElement = ride_get_station_start_track_element(ride, stationIndex);
|
||||
|
||||
// If no station track found return
|
||||
if (mapElement == nullptr)
|
||||
if (tileElement == nullptr)
|
||||
return;
|
||||
|
||||
tile_element_set_green_light(mapElement, greenLight);
|
||||
tile_element_set_green_light(tileElement, greenLight);
|
||||
|
||||
// Invalidate map tile
|
||||
map_invalidate_tile_zoom1(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
|
||||
map_invalidate_tile_zoom1(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
|
||||
}
|
||||
|
||||
rct_tile_element * ride_get_station_start_track_element(Ride * ride, sint32 stationIndex)
|
||||
|
@ -315,14 +315,14 @@ rct_tile_element * ride_get_station_start_track_element(Ride * ride, sint32 stat
|
|||
sint32 z = ride->station_heights[stationIndex];
|
||||
|
||||
// Find the station track element
|
||||
rct_tile_element * mapElement = map_get_first_element_at(x, y);
|
||||
rct_tile_element * tileElement = map_get_first_element_at(x, y);
|
||||
do
|
||||
{
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK && z == mapElement->base_height)
|
||||
return mapElement;
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK && z == tileElement->base_height)
|
||||
return tileElement;
|
||||
|
||||
}
|
||||
while (!tile_element_is_last_for_tile(mapElement++));
|
||||
while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
@ -330,13 +330,13 @@ rct_tile_element * ride_get_station_start_track_element(Ride * ride, sint32 stat
|
|||
rct_tile_element * ride_get_station_exit_element(Ride * ride, sint32 x, sint32 y, sint32 z)
|
||||
{
|
||||
// Find the station track element
|
||||
rct_tile_element * mapElement = map_get_first_element_at(x, y);
|
||||
rct_tile_element * tileElement = map_get_first_element_at(x, y);
|
||||
do
|
||||
{
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE && z == mapElement->base_height)
|
||||
return mapElement;
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE && z == tileElement->base_height)
|
||||
return tileElement;
|
||||
}
|
||||
while (!tile_element_is_last_for_tile(mapElement++));
|
||||
while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
|
|
@ -605,23 +605,23 @@ const rct_preview_track * get_track_def_from_ride_index(sint32 rideIndex, sint32
|
|||
|
||||
static rct_tile_element * find_station_element(sint32 x, sint32 y, sint32 z, sint32 direction, sint32 rideIndex)
|
||||
{
|
||||
rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
do
|
||||
{
|
||||
if (z != mapElement->base_height)
|
||||
if (z != tileElement->base_height)
|
||||
continue;
|
||||
if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
continue;
|
||||
if (tile_element_get_direction(mapElement) != direction)
|
||||
if (tile_element_get_direction(tileElement) != direction)
|
||||
continue;
|
||||
if (mapElement->properties.track.ride_index != rideIndex)
|
||||
if (tileElement->properties.track.ride_index != rideIndex)
|
||||
continue;
|
||||
if (!track_element_is_station(mapElement))
|
||||
if (!track_element_is_station(tileElement))
|
||||
continue;
|
||||
|
||||
return mapElement;
|
||||
return tileElement;
|
||||
}
|
||||
while (!tile_element_is_last_for_tile(mapElement++));
|
||||
while (!tile_element_is_last_for_tile(tileElement++));
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
@ -812,8 +812,8 @@ static bool track_remove_station_element(sint32 x, sint32 y, sint32 z, sint32 di
|
|||
Ride * ride = get_ride(rideIndex);
|
||||
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3))
|
||||
{
|
||||
rct_tile_element * mapElement = map_get_track_element_at_with_direction_from_ride(x, y, z, direction, rideIndex);
|
||||
if (mapElement != nullptr)
|
||||
rct_tile_element * tileElement = map_get_track_element_at_with_direction_from_ride(x, y, z, direction, rideIndex);
|
||||
if (tileElement != nullptr)
|
||||
{
|
||||
if (flags & GAME_COMMAND_FLAG_APPLY)
|
||||
{
|
||||
|
@ -991,7 +991,7 @@ static money32 track_place(sint32 rideIndex,
|
|||
log_warning("Invalid ride type for track placement, rideIndex = %d", rideIndex);
|
||||
return MONEY32_UNDEFINED;
|
||||
}
|
||||
rct_tile_element * mapElement;
|
||||
rct_tile_element * tileElement;
|
||||
|
||||
gCommandExpenditureType = RCT_EXPENDITURE_TYPE_RIDE_CONSTRUCTION;
|
||||
gCommandPosition.x = originX + 16;
|
||||
|
@ -1295,9 +1295,9 @@ static money32 track_place(sint32 rideIndex,
|
|||
|
||||
if ((rideTypeFlags & RIDE_TYPE_FLAG_TRACK_MUST_BE_ON_WATER) && !byte_9D8150)
|
||||
{
|
||||
mapElement = map_get_surface_element_at(x / 32, y / 32);
|
||||
tileElement = map_get_surface_element_at(x / 32, y / 32);
|
||||
|
||||
uint8 water_height = map_get_water_height(mapElement) * 2;
|
||||
uint8 water_height = map_get_water_height(tileElement) * 2;
|
||||
if (water_height == 0)
|
||||
{
|
||||
gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_ON_WATER;
|
||||
|
@ -1310,9 +1310,9 @@ static money32 track_place(sint32 rideIndex,
|
|||
return MONEY32_UNDEFINED;
|
||||
}
|
||||
water_height -= 2;
|
||||
if (water_height == mapElement->base_height)
|
||||
if (water_height == tileElement->base_height)
|
||||
{
|
||||
bh = mapElement->properties.surface.slope & 0x0F;
|
||||
bh = tileElement->properties.surface.slope & 0x0F;
|
||||
if (bh == 7 || bh == 11 || bh == 13 || bh == 14)
|
||||
{
|
||||
gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_ON_WATER;
|
||||
|
@ -1362,10 +1362,10 @@ static money32 track_place(sint32 rideIndex,
|
|||
}
|
||||
}
|
||||
//6c5648 12 push
|
||||
mapElement = map_get_surface_element_at(x / 32, y / 32);
|
||||
tileElement = map_get_surface_element_at(x / 32, y / 32);
|
||||
if (!gCheatsDisableSupportLimits)
|
||||
{
|
||||
sint32 ride_height = clearanceZ - mapElement->base_height;
|
||||
sint32 ride_height = clearanceZ - tileElement->base_height;
|
||||
if (ride_height >= 0)
|
||||
{
|
||||
|
||||
|
@ -1402,7 +1402,7 @@ static money32 track_place(sint32 rideIndex,
|
|||
}
|
||||
}
|
||||
|
||||
sint32 _support_height = baseZ - mapElement->base_height;
|
||||
sint32 _support_height = baseZ - tileElement->base_height;
|
||||
if (_support_height < 0)
|
||||
{
|
||||
_support_height = 10;
|
||||
|
@ -1478,9 +1478,9 @@ static money32 track_place(sint32 rideIndex,
|
|||
ride->overall_view.y = y / 32;
|
||||
}
|
||||
|
||||
mapElement = tile_element_insert(x / 32, y / 32, baseZ, bl & 0xF);
|
||||
assert(mapElement != nullptr);
|
||||
mapElement->clearance_height = clearanceZ;
|
||||
tileElement = tile_element_insert(x / 32, y / 32, baseZ, bl & 0xF);
|
||||
assert(tileElement != nullptr);
|
||||
tileElement->clearance_height = clearanceZ;
|
||||
|
||||
uint8 map_type = direction;
|
||||
map_type |= TILE_ELEMENT_TYPE_TRACK;
|
||||
|
@ -1488,46 +1488,46 @@ static money32 track_place(sint32 rideIndex,
|
|||
{
|
||||
map_type |= (1 << 7);
|
||||
}
|
||||
mapElement->type = map_type;
|
||||
tileElement->type = map_type;
|
||||
|
||||
tile_element_set_track_sequence(mapElement, trackBlock->index);
|
||||
mapElement->properties.track.ride_index = rideIndex;
|
||||
mapElement->properties.track.type = type;
|
||||
mapElement->properties.track.colour = 0;
|
||||
tile_element_set_track_sequence(tileElement, trackBlock->index);
|
||||
tileElement->properties.track.ride_index = rideIndex;
|
||||
tileElement->properties.track.type = type;
|
||||
tileElement->properties.track.colour = 0;
|
||||
if (flags & GAME_COMMAND_FLAG_GHOST)
|
||||
{
|
||||
mapElement->flags |= TILE_ELEMENT_FLAG_GHOST;
|
||||
tileElement->flags |= TILE_ELEMENT_FLAG_GHOST;
|
||||
}
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case TRACK_ELEM_WATERFALL:
|
||||
map_animation_create(MAP_ANIMATION_TYPE_TRACK_WATERFALL, x, y, mapElement->base_height);
|
||||
map_animation_create(MAP_ANIMATION_TYPE_TRACK_WATERFALL, x, y, tileElement->base_height);
|
||||
break;
|
||||
case TRACK_ELEM_RAPIDS:
|
||||
map_animation_create(MAP_ANIMATION_TYPE_TRACK_RAPIDS, x, y, mapElement->base_height);
|
||||
map_animation_create(MAP_ANIMATION_TYPE_TRACK_RAPIDS, x, y, tileElement->base_height);
|
||||
break;
|
||||
case TRACK_ELEM_WHIRLPOOL:
|
||||
map_animation_create(MAP_ANIMATION_TYPE_TRACK_WHIRLPOOL, x, y, mapElement->base_height);
|
||||
map_animation_create(MAP_ANIMATION_TYPE_TRACK_WHIRLPOOL, x, y, tileElement->base_height);
|
||||
break;
|
||||
case TRACK_ELEM_SPINNING_TUNNEL:
|
||||
map_animation_create(MAP_ANIMATION_TYPE_TRACK_SPINNINGTUNNEL, x, y, mapElement->base_height);
|
||||
map_animation_create(MAP_ANIMATION_TYPE_TRACK_SPINNINGTUNNEL, x, y, tileElement->base_height);
|
||||
break;
|
||||
}
|
||||
if (track_element_has_speed_setting(type))
|
||||
{
|
||||
tile_element_set_brake_booster_speed(mapElement, brakeSpeed);
|
||||
tile_element_set_brake_booster_speed(tileElement, brakeSpeed);
|
||||
}
|
||||
else
|
||||
{
|
||||
track_element_set_seat_rotation(mapElement, seatRotation);
|
||||
track_element_set_seat_rotation(tileElement, seatRotation);
|
||||
}
|
||||
|
||||
if (liftHillAndAlternativeState & RIDE_TYPE_ALTERNATIVE_TRACK_TYPE)
|
||||
{
|
||||
track_element_set_inverted(mapElement, true);
|
||||
track_element_set_inverted(tileElement, true);
|
||||
}
|
||||
track_element_set_colour_scheme(mapElement, colour);
|
||||
track_element_set_colour_scheme(tileElement, colour);
|
||||
|
||||
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
|
||||
{
|
||||
|
@ -1552,12 +1552,12 @@ static money32 track_place(sint32 rideIndex,
|
|||
{
|
||||
rct_tile_element * surfaceElement = map_get_surface_element_at(x / 32, y / 32);
|
||||
surfaceElement->type |= (1 << 6);
|
||||
mapElement = surfaceElement;
|
||||
tileElement = surfaceElement;
|
||||
}
|
||||
|
||||
if (!gCheatsDisableClearanceChecks || !(flags & GAME_COMMAND_FLAG_GHOST))
|
||||
{
|
||||
footpath_connect_edges(x, y, mapElement, flags);
|
||||
footpath_connect_edges(x, y, tileElement, flags);
|
||||
}
|
||||
map_invalidate_tile_full(x, y);
|
||||
}
|
||||
|
@ -1645,29 +1645,29 @@ static money32 track_remove(uint8 type,
|
|||
}
|
||||
|
||||
uint8 found = 0;
|
||||
rct_tile_element * mapElement = map_get_first_element_at(originX / 32, originY / 32);
|
||||
if (mapElement == nullptr)
|
||||
rct_tile_element * tileElement = map_get_first_element_at(originX / 32, originY / 32);
|
||||
if (tileElement == nullptr)
|
||||
{
|
||||
log_warning("Invalid coordinates for track removal. x = %d, y = %d", originX, originY);
|
||||
return MONEY32_UNDEFINED;
|
||||
}
|
||||
do
|
||||
{
|
||||
if (mapElement->base_height * 8 != originZ)
|
||||
if (tileElement->base_height * 8 != originZ)
|
||||
continue;
|
||||
|
||||
if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
continue;
|
||||
|
||||
if ((tile_element_get_direction(mapElement)) != rotation)
|
||||
if ((tile_element_get_direction(tileElement)) != rotation)
|
||||
continue;
|
||||
|
||||
if (tile_element_get_track_sequence(mapElement) != sequence)
|
||||
if (tile_element_get_track_sequence(tileElement) != sequence)
|
||||
continue;
|
||||
|
||||
// Probably should add a check for ghost here as well!
|
||||
|
||||
uint8 track_type = mapElement->properties.track.type;
|
||||
uint8 track_type = tileElement->properties.track.type;
|
||||
switch (track_type)
|
||||
{
|
||||
case TRACK_ELEM_BEGIN_STATION:
|
||||
|
@ -1682,28 +1682,28 @@ static money32 track_remove(uint8 type,
|
|||
found = 1;
|
||||
break;
|
||||
}
|
||||
while (!tile_element_is_last_for_tile(mapElement++));
|
||||
while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
if (!found)
|
||||
{
|
||||
return MONEY32_UNDEFINED;
|
||||
}
|
||||
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE)
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE)
|
||||
{
|
||||
gGameCommandErrorText = STR_YOU_ARE_NOT_ALLOWED_TO_REMOVE_THIS_SECTION;
|
||||
return MONEY32_UNDEFINED;
|
||||
}
|
||||
|
||||
uint8 rideIndex = mapElement->properties.track.ride_index;
|
||||
type = mapElement->properties.track.type;
|
||||
bool isLiftHill = track_element_is_lift_hill(mapElement);
|
||||
uint8 rideIndex = tileElement->properties.track.ride_index;
|
||||
type = tileElement->properties.track.type;
|
||||
bool isLiftHill = track_element_is_lift_hill(tileElement);
|
||||
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
const rct_preview_track * trackBlock = get_track_def_from_ride(ride, type);
|
||||
trackBlock += tile_element_get_track_sequence(mapElement);
|
||||
trackBlock += tile_element_get_track_sequence(tileElement);
|
||||
|
||||
uint8 originDirection = tile_element_get_direction(mapElement);
|
||||
uint8 originDirection = tile_element_get_direction(tileElement);
|
||||
switch (originDirection)
|
||||
{
|
||||
case 0:
|
||||
|
@ -1760,31 +1760,31 @@ static money32 track_remove(uint8 type,
|
|||
trackpieceZ = z;
|
||||
|
||||
found = 0;
|
||||
mapElement = map_get_first_element_at(x / 32, y / 32);
|
||||
tileElement = map_get_first_element_at(x / 32, y / 32);
|
||||
do
|
||||
{
|
||||
if (mapElement == nullptr)
|
||||
if (tileElement == nullptr)
|
||||
break;
|
||||
|
||||
if (mapElement->base_height != z / 8)
|
||||
if (tileElement->base_height != z / 8)
|
||||
continue;
|
||||
|
||||
if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
continue;
|
||||
|
||||
if ((tile_element_get_direction(mapElement)) != rotation)
|
||||
if ((tile_element_get_direction(tileElement)) != rotation)
|
||||
continue;
|
||||
|
||||
if (tile_element_get_track_sequence(mapElement) != trackBlock->index)
|
||||
if (tile_element_get_track_sequence(tileElement) != trackBlock->index)
|
||||
continue;
|
||||
|
||||
if (mapElement->properties.track.type != type)
|
||||
if (tileElement->properties.track.type != type)
|
||||
continue;
|
||||
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
while (!tile_element_is_last_for_tile(mapElement++));
|
||||
while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
if (!found)
|
||||
{
|
||||
|
@ -1802,7 +1802,7 @@ static money32 track_remove(uint8 type,
|
|||
entranceDirections = TrackSequenceProperties[type][0];
|
||||
}
|
||||
|
||||
if (entranceDirections & TRACK_SEQUENCE_FLAG_ORIGIN && (tile_element_get_track_sequence(mapElement) == 0))
|
||||
if (entranceDirections & TRACK_SEQUENCE_FLAG_ORIGIN && (tile_element_get_track_sequence(tileElement) == 0))
|
||||
{
|
||||
if (!track_remove_station_element(x, y, z / 8, rotation, rideIndex, 0))
|
||||
{
|
||||
|
@ -1816,7 +1816,7 @@ static money32 track_remove(uint8 type,
|
|||
return MONEY32_UNDEFINED;
|
||||
}
|
||||
|
||||
sint8 _support_height = mapElement->base_height - surfaceElement->base_height;
|
||||
sint8 _support_height = tileElement->base_height - surfaceElement->base_height;
|
||||
if (_support_height < 0)
|
||||
{
|
||||
_support_height = 10;
|
||||
|
@ -1827,7 +1827,7 @@ static money32 track_remove(uint8 type,
|
|||
if (!(flags & GAME_COMMAND_FLAG_APPLY))
|
||||
continue;
|
||||
|
||||
if (entranceDirections & (1 << 4) && (tile_element_get_track_sequence(mapElement) == 0))
|
||||
if (entranceDirections & (1 << 4) && (tile_element_get_track_sequence(tileElement) == 0))
|
||||
{
|
||||
if (!track_remove_station_element(x, y, z / 8, rotation, rideIndex, GAME_COMMAND_FLAG_APPLY))
|
||||
{
|
||||
|
@ -1842,11 +1842,11 @@ static money32 track_remove(uint8 type,
|
|||
|
||||
invalidate_test_results(rideIndex);
|
||||
footpath_queue_chain_reset();
|
||||
if (!gCheatsDisableClearanceChecks || !(mapElement->flags & TILE_ELEMENT_FLAG_GHOST))
|
||||
if (!gCheatsDisableClearanceChecks || !(tileElement->flags & TILE_ELEMENT_FLAG_GHOST))
|
||||
{
|
||||
footpath_remove_edges_at(x, y, mapElement);
|
||||
footpath_remove_edges_at(x, y, tileElement);
|
||||
}
|
||||
tile_element_remove(mapElement);
|
||||
tile_element_remove(tileElement);
|
||||
if (!(flags & GAME_COMMAND_FLAG_GHOST))
|
||||
{
|
||||
sub_6CB945(rideIndex);
|
||||
|
@ -2030,8 +2030,8 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
|
|||
return MONEY32_UNDEFINED;
|
||||
}
|
||||
|
||||
rct_tile_element * mapElement = map_get_surface_element_at(x / 32, y / 32);
|
||||
if (mapElement == nullptr)
|
||||
rct_tile_element * tileElement = map_get_surface_element_at(x / 32, y / 32);
|
||||
if (tileElement == nullptr)
|
||||
{
|
||||
return MONEY32_UNDEFINED;
|
||||
}
|
||||
|
@ -2039,7 +2039,7 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
|
|||
uint8 baseHeight = z >> 3;
|
||||
uint8 clearanceHeight = (z + 32) >> 3;
|
||||
|
||||
sint8 heightDifference = baseHeight - mapElement->base_height;
|
||||
sint8 heightDifference = baseHeight - tileElement->base_height;
|
||||
if (heightDifference >= 0 && !gCheatsDisableSupportLimits)
|
||||
{
|
||||
heightDifference = heightDifference >> 1;
|
||||
|
@ -2051,8 +2051,8 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
|
|||
}
|
||||
}
|
||||
|
||||
mapElement = map_get_track_element_at_of_type_from_ride(x, y, baseHeight, TRACK_ELEM_MAZE, rideIndex);
|
||||
if (mapElement == nullptr)
|
||||
tileElement = map_get_track_element_at_of_type_from_ride(x, y, baseHeight, TRACK_ELEM_MAZE, rideIndex);
|
||||
if (tileElement == nullptr)
|
||||
{
|
||||
if (mode != GC_SET_MAZE_TRACK_BUILD)
|
||||
{
|
||||
|
@ -2095,23 +2095,23 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
|
|||
uint16 flooredX = floor2(x, 32);
|
||||
uint16 flooredY = floor2(y, 32);
|
||||
|
||||
mapElement = tile_element_insert(x / 32, y / 32, baseHeight, 0xF);
|
||||
assert(mapElement != nullptr);
|
||||
mapElement->clearance_height = clearanceHeight;
|
||||
mapElement->type = TILE_ELEMENT_TYPE_TRACK;
|
||||
mapElement->properties.track.type = TRACK_ELEM_MAZE;
|
||||
mapElement->properties.track.ride_index = rideIndex;
|
||||
mapElement->properties.track.maze_entry = 0xFFFF;
|
||||
tileElement = tile_element_insert(x / 32, y / 32, baseHeight, 0xF);
|
||||
assert(tileElement != nullptr);
|
||||
tileElement->clearance_height = clearanceHeight;
|
||||
tileElement->type = TILE_ELEMENT_TYPE_TRACK;
|
||||
tileElement->properties.track.type = TRACK_ELEM_MAZE;
|
||||
tileElement->properties.track.ride_index = rideIndex;
|
||||
tileElement->properties.track.maze_entry = 0xFFFF;
|
||||
|
||||
if (flags & GAME_COMMAND_FLAG_GHOST)
|
||||
{
|
||||
mapElement->flags |= TILE_ELEMENT_FLAG_GHOST;
|
||||
tileElement->flags |= TILE_ELEMENT_FLAG_GHOST;
|
||||
}
|
||||
|
||||
map_invalidate_tile_full(flooredX, flooredY);
|
||||
|
||||
ride->maze_tiles++;
|
||||
ride->station_heights[0] = mapElement->base_height;
|
||||
ride->station_heights[0] = tileElement->base_height;
|
||||
ride->station_starts[0].xy = 0;
|
||||
|
||||
if (direction == 4)
|
||||
|
@ -2141,12 +2141,12 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
|
|||
{
|
||||
uint8 segmentOffset = maze_element_get_segment_bit(x, y);
|
||||
|
||||
mapElement->properties.track.maze_entry &= ~(1 << segmentOffset);
|
||||
tileElement->properties.track.maze_entry &= ~(1 << segmentOffset);
|
||||
|
||||
if (direction != 4)
|
||||
{
|
||||
segmentOffset = byte_993CE9[(direction + segmentOffset)];
|
||||
mapElement->properties.track.maze_entry &= ~(1 << segmentOffset);
|
||||
tileElement->properties.track.maze_entry &= ~(1 << segmentOffset);
|
||||
|
||||
uint8 temp_edx = byte_993CFC[segmentOffset];
|
||||
if (temp_edx != 0xFF)
|
||||
|
@ -2154,19 +2154,19 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
|
|||
uint16 previousElementX = floor2(x, 32) - TileDirectionDelta[direction].x;
|
||||
uint16 previousElementY = floor2(y, 32) - TileDirectionDelta[direction].y;
|
||||
|
||||
rct_tile_element * previousMapElement = map_get_track_element_at_of_type_from_ride(
|
||||
rct_tile_element * previousTileElement = map_get_track_element_at_of_type_from_ride(
|
||||
previousElementX,
|
||||
previousElementY,
|
||||
baseHeight,
|
||||
TRACK_ELEM_MAZE,
|
||||
rideIndex);
|
||||
if (previousMapElement != nullptr)
|
||||
if (previousTileElement != nullptr)
|
||||
{
|
||||
previousMapElement->properties.track.maze_entry &= ~(1 << temp_edx);
|
||||
previousTileElement->properties.track.maze_entry &= ~(1 << temp_edx);
|
||||
}
|
||||
else
|
||||
{
|
||||
mapElement->properties.track.maze_entry |= (1 << segmentOffset);
|
||||
tileElement->properties.track.maze_entry |= (1 << segmentOffset);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -2183,14 +2183,14 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
|
|||
uint16 previousSegmentX = x - TileDirectionDelta[direction].x / 2;
|
||||
uint16 previousSegmentY = y - TileDirectionDelta[direction].y / 2;
|
||||
|
||||
mapElement = map_get_track_element_at_of_type_from_ride(
|
||||
tileElement = map_get_track_element_at_of_type_from_ride(
|
||||
previousSegmentX,
|
||||
previousSegmentY,
|
||||
baseHeight,
|
||||
TRACK_ELEM_MAZE,
|
||||
rideIndex);
|
||||
map_invalidate_tile_full(floor2(previousSegmentX, 32), floor2(previousSegmentY, 32));
|
||||
if (mapElement == nullptr)
|
||||
if (tileElement == nullptr)
|
||||
{
|
||||
log_error("No surface found");
|
||||
return MONEY32_UNDEFINED;
|
||||
|
@ -2198,31 +2198,31 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
|
|||
|
||||
uint32 segmentBit = maze_element_get_segment_bit(previousSegmentX, previousSegmentY);
|
||||
|
||||
mapElement->properties.track.maze_entry |= (1 << segmentBit);
|
||||
tileElement->properties.track.maze_entry |= (1 << segmentBit);
|
||||
segmentBit--;
|
||||
mapElement->properties.track.maze_entry |= (1 << segmentBit);
|
||||
tileElement->properties.track.maze_entry |= (1 << segmentBit);
|
||||
segmentBit = (segmentBit - 4) & 0x0F;
|
||||
mapElement->properties.track.maze_entry |= (1 << segmentBit);
|
||||
tileElement->properties.track.maze_entry |= (1 << segmentBit);
|
||||
segmentBit = (segmentBit + 3) & 0x0F;
|
||||
|
||||
do
|
||||
{
|
||||
mapElement->properties.track.maze_entry |= (1 << segmentBit);
|
||||
tileElement->properties.track.maze_entry |= (1 << segmentBit);
|
||||
|
||||
uint32 direction1 = byte_993D0C[segmentBit];
|
||||
uint16 nextElementX = floor2(previousSegmentX, 32) + TileDirectionDelta[direction1].x;
|
||||
uint16 nextElementY = floor2(previousSegmentY, 32) + TileDirectionDelta[direction1].y;
|
||||
|
||||
rct_tile_element * tmp_mapElement = map_get_track_element_at_of_type_from_ride(
|
||||
rct_tile_element * tmp_tileElement = map_get_track_element_at_of_type_from_ride(
|
||||
nextElementX,
|
||||
nextElementY,
|
||||
baseHeight,
|
||||
TRACK_ELEM_MAZE,
|
||||
rideIndex);
|
||||
if (tmp_mapElement != nullptr)
|
||||
if (tmp_tileElement != nullptr)
|
||||
{
|
||||
uint8 edx11 = byte_993CFC[segmentBit];
|
||||
tmp_mapElement->properties.track.maze_entry |= 1 << (edx11);
|
||||
tmp_tileElement->properties.track.maze_entry |= 1 << (edx11);
|
||||
}
|
||||
|
||||
segmentBit--;
|
||||
|
@ -2232,11 +2232,11 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
|
|||
break;
|
||||
}
|
||||
|
||||
map_invalidate_tile(floor2(x, 32), floor2(y, 32), mapElement->base_height * 8, mapElement->clearance_height * 8);
|
||||
map_invalidate_tile(floor2(x, 32), floor2(y, 32), tileElement->base_height * 8, tileElement->clearance_height * 8);
|
||||
|
||||
if ((mapElement->properties.track.maze_entry & 0x8888) == 0x8888)
|
||||
if ((tileElement->properties.track.maze_entry & 0x8888) == 0x8888)
|
||||
{
|
||||
tile_element_remove(mapElement);
|
||||
tile_element_remove(tileElement);
|
||||
sub_6CB945(rideIndex);
|
||||
get_ride(rideIndex)->maze_tiles--;
|
||||
}
|
||||
|
@ -2301,8 +2301,8 @@ void game_command_set_brakes_speed(sint32 * eax,
|
|||
return;
|
||||
}
|
||||
|
||||
rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
if (mapElement == nullptr)
|
||||
rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
if (tileElement == nullptr)
|
||||
{
|
||||
log_warning("Invalid game command for setting brakes speed. x = %d, y = %d", x, y);
|
||||
*ebx = MONEY32_UNDEFINED;
|
||||
|
@ -2310,18 +2310,18 @@ void game_command_set_brakes_speed(sint32 * eax,
|
|||
}
|
||||
do
|
||||
{
|
||||
if (mapElement->base_height * 8 != z)
|
||||
if (tileElement->base_height * 8 != z)
|
||||
continue;
|
||||
if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
continue;
|
||||
if (mapElement->properties.track.type != trackType)
|
||||
if (tileElement->properties.track.type != trackType)
|
||||
continue;
|
||||
|
||||
tile_element_set_brake_booster_speed(mapElement, brakesSpeed);
|
||||
tile_element_set_brake_booster_speed(tileElement, brakesSpeed);
|
||||
|
||||
break;
|
||||
}
|
||||
while (!tile_element_is_last_for_tile(mapElement++));
|
||||
while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
*ebx = 0;
|
||||
}
|
||||
|
@ -2489,27 +2489,27 @@ void track_element_clear_cable_lift(rct_tile_element * trackElement)
|
|||
trackElement->properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
|
||||
}
|
||||
|
||||
bool track_element_is_inverted(rct_tile_element * mapElement)
|
||||
bool track_element_is_inverted(rct_tile_element * tileElement)
|
||||
{
|
||||
return mapElement->properties.track.colour & TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
|
||||
return tileElement->properties.track.colour & TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
|
||||
}
|
||||
|
||||
void track_element_set_inverted(rct_tile_element * mapElement, bool inverted)
|
||||
void track_element_set_inverted(rct_tile_element * tileElement, bool inverted)
|
||||
{
|
||||
if (inverted)
|
||||
{
|
||||
mapElement->properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
|
||||
tileElement->properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
|
||||
}
|
||||
else
|
||||
{
|
||||
mapElement->properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
|
||||
tileElement->properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
|
||||
}
|
||||
}
|
||||
|
||||
sint32 track_get_actual_bank(rct_tile_element * mapElement, sint32 bank)
|
||||
sint32 track_get_actual_bank(rct_tile_element * tileElement, sint32 bank)
|
||||
{
|
||||
Ride * ride = get_ride(mapElement->properties.track.ride_index);
|
||||
sint32 trackColour = mapElement->properties.track.colour;
|
||||
Ride * ride = get_ride(tileElement->properties.track.ride_index);
|
||||
sint32 trackColour = tileElement->properties.track.colour;
|
||||
return track_get_actual_bank_2(ride->type, trackColour, bank);
|
||||
}
|
||||
|
||||
|
@ -2532,12 +2532,12 @@ sint32 track_get_actual_bank_2(sint32 rideType, sint32 trackColour, sint32 bank)
|
|||
return bank;
|
||||
}
|
||||
|
||||
sint32 track_get_actual_bank_3(rct_vehicle * vehicle, rct_tile_element * mapElement)
|
||||
sint32 track_get_actual_bank_3(rct_vehicle * vehicle, rct_tile_element * tileElement)
|
||||
{
|
||||
uint8 colourThingToXor = (vehicle->update_flags >> 9) & 0xFF;
|
||||
sint32 trackType = mapElement->properties.track.type;
|
||||
sint32 rideType = get_ride(mapElement->properties.track.ride_index)->type;
|
||||
sint32 trackColour = mapElement->properties.track.colour ^ colourThingToXor;
|
||||
sint32 trackType = tileElement->properties.track.type;
|
||||
sint32 rideType = get_ride(tileElement->properties.track.ride_index)->type;
|
||||
sint32 trackColour = tileElement->properties.track.colour ^ colourThingToXor;
|
||||
sint32 bankStart = TrackDefinitions[trackType].bank_start;
|
||||
return track_get_actual_bank_2(rideType, trackColour, bankStart);
|
||||
}
|
||||
|
@ -2605,24 +2605,24 @@ bool track_element_has_speed_setting(uint8 trackType)
|
|||
return false;
|
||||
}
|
||||
|
||||
uint8 track_element_get_seat_rotation(const rct_tile_element * mapElement)
|
||||
uint8 track_element_get_seat_rotation(const rct_tile_element * tileElement)
|
||||
{
|
||||
return mapElement->properties.track.colour >> 4;
|
||||
return tileElement->properties.track.colour >> 4;
|
||||
}
|
||||
|
||||
void track_element_set_seat_rotation(rct_tile_element * mapElement, uint8 seatRotation)
|
||||
void track_element_set_seat_rotation(rct_tile_element * tileElement, uint8 seatRotation)
|
||||
{
|
||||
mapElement->properties.track.colour &= 0x0F;
|
||||
mapElement->properties.track.colour |= (seatRotation << 4);
|
||||
tileElement->properties.track.colour &= 0x0F;
|
||||
tileElement->properties.track.colour |= (seatRotation << 4);
|
||||
}
|
||||
|
||||
uint8 track_element_get_colour_scheme(const rct_tile_element * mapElement)
|
||||
uint8 track_element_get_colour_scheme(const rct_tile_element * tileElement)
|
||||
{
|
||||
return mapElement->properties.track.colour & 0x3;
|
||||
return tileElement->properties.track.colour & 0x3;
|
||||
}
|
||||
|
||||
void track_element_set_colour_scheme(rct_tile_element * mapElement, uint8 colourScheme)
|
||||
void track_element_set_colour_scheme(rct_tile_element * tileElement, uint8 colourScheme)
|
||||
{
|
||||
mapElement->properties.track.colour &= ~0x3;
|
||||
mapElement->properties.track.colour |= (colourScheme & 0x3);
|
||||
tileElement->properties.track.colour &= ~0x3;
|
||||
tileElement->properties.track.colour |= (colourScheme & 0x3);
|
||||
}
|
||||
|
|
|
@ -548,12 +548,12 @@ bool track_element_is_lift_hill(rct_tile_element * trackElement);
|
|||
bool track_element_is_cable_lift(rct_tile_element * trackElement);
|
||||
void track_element_set_cable_lift(rct_tile_element * trackElement);
|
||||
void track_element_clear_cable_lift(rct_tile_element * trackElement);
|
||||
bool track_element_is_inverted(rct_tile_element * mapElement);
|
||||
void track_element_set_inverted(rct_tile_element * mapElement, bool inverted);
|
||||
bool track_element_is_inverted(rct_tile_element * tileElement);
|
||||
void track_element_set_inverted(rct_tile_element * tileElement, bool inverted);
|
||||
|
||||
sint32 track_get_actual_bank(rct_tile_element * mapElement, sint32 bank);
|
||||
sint32 track_get_actual_bank(rct_tile_element * tileElement, sint32 bank);
|
||||
sint32 track_get_actual_bank_2(sint32 rideType, sint32 trackColour, sint32 bank);
|
||||
sint32 track_get_actual_bank_3(rct_vehicle * vehicle, rct_tile_element * mapElement);
|
||||
sint32 track_get_actual_bank_3(rct_vehicle * vehicle, rct_tile_element * tileElement);
|
||||
|
||||
void game_command_place_track(sint32 * eax, sint32 * ebx, sint32 * ecx, sint32 * edx, sint32 * esi, sint32 * edi, sint32 * ebp);
|
||||
void game_command_remove_track(sint32 * eax, sint32 * ebx, sint32 * ecx, sint32 * edx, sint32 * esi, sint32 * edi, sint32 * ebp);
|
||||
|
@ -561,10 +561,10 @@ void game_command_set_maze_track(sint32 * eax, sint32 * ebx, sint32 * ecx, sint3
|
|||
void game_command_set_brakes_speed(sint32 * eax, sint32 * ebx, sint32 * ecx, sint32 * edx, sint32 * esi, sint32 * edi, sint32 * ebp);
|
||||
bool track_element_is_booster(uint8 rideType, uint8 trackType);
|
||||
bool track_element_has_speed_setting(uint8 trackType);
|
||||
uint8 track_element_get_seat_rotation(const rct_tile_element * mapElement);
|
||||
void track_element_set_seat_rotation(rct_tile_element * mapElement, uint8 seatRotation);
|
||||
uint8 track_element_get_colour_scheme(const rct_tile_element * mapElement);
|
||||
void track_element_set_colour_scheme(rct_tile_element * mapElement, uint8 colourScheme);
|
||||
uint8 track_element_get_seat_rotation(const rct_tile_element * tileElement);
|
||||
void track_element_set_seat_rotation(rct_tile_element * tileElement, uint8 seatRotation);
|
||||
uint8 track_element_get_colour_scheme(const rct_tile_element * tileElement);
|
||||
void track_element_set_colour_scheme(rct_tile_element * tileElement, uint8 colourScheme);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -1478,23 +1478,23 @@ static bool track_design_place_ride(rct_track_td6 * td6, sint16 x, sint16 y, sin
|
|||
continue;
|
||||
}
|
||||
|
||||
rct_tile_element * mapElement = map_get_surface_element_at(tile.x >> 5, tile.y >> 5);
|
||||
if (mapElement == NULL)
|
||||
rct_tile_element * tileElement = map_get_surface_element_at(tile.x >> 5, tile.y >> 5);
|
||||
if (tileElement == NULL)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
sint32 height = mapElement->base_height * 8;
|
||||
if (mapElement->properties.surface.slope & 0x0F)
|
||||
sint32 height = tileElement->base_height * 8;
|
||||
if (tileElement->properties.surface.slope & 0x0F)
|
||||
{
|
||||
height += 16;
|
||||
if (mapElement->properties.surface.slope & 0x10)
|
||||
if (tileElement->properties.surface.slope & 0x10)
|
||||
{
|
||||
height += 16;
|
||||
}
|
||||
}
|
||||
|
||||
uint8 water_height = map_get_water_height(mapElement) * 16;
|
||||
uint8 water_height = map_get_water_height(tileElement) * 16;
|
||||
if (water_height > 0 && water_height > height)
|
||||
{
|
||||
height = water_height;
|
||||
|
@ -2041,11 +2041,11 @@ static money32 place_maze_design(uint8 flags, uint8 rideIndex, uint16 mazeEntry,
|
|||
// Check support height
|
||||
if (!gCheatsDisableSupportLimits)
|
||||
{
|
||||
rct_tile_element * mapElement = map_get_surface_element_at(x >> 5, y >> 5);
|
||||
rct_tile_element * tileElement = map_get_surface_element_at(x >> 5, y >> 5);
|
||||
uint8 supportZ = (z + 32) >> 3;
|
||||
if (supportZ > mapElement->base_height)
|
||||
if (supportZ > tileElement->base_height)
|
||||
{
|
||||
uint8 supportHeight = (supportZ - mapElement->base_height) / 2;
|
||||
uint8 supportHeight = (supportZ - tileElement->base_height) / 2;
|
||||
uint8 maxSupportHeight = RideData5[RIDE_TYPE_MAZE].max_height;
|
||||
if (supportHeight > maxSupportHeight)
|
||||
{
|
||||
|
@ -2109,21 +2109,21 @@ static money32 place_maze_design(uint8 flags, uint8 rideIndex, uint16 mazeEntry,
|
|||
sint32 fx = floor2(x, 32);
|
||||
sint32 fy = floor2(y, 32);
|
||||
sint32 fz = z >> 3;
|
||||
rct_tile_element * mapElement = tile_element_insert(fx >> 5, fy >> 5, fz, 15);
|
||||
mapElement->clearance_height = fz + 4;
|
||||
mapElement->type = TILE_ELEMENT_TYPE_TRACK;
|
||||
mapElement->properties.track.type = TRACK_ELEM_MAZE;
|
||||
mapElement->properties.track.ride_index = rideIndex;
|
||||
mapElement->properties.track.maze_entry = mazeEntry;
|
||||
rct_tile_element * tileElement = tile_element_insert(fx >> 5, fy >> 5, fz, 15);
|
||||
tileElement->clearance_height = fz + 4;
|
||||
tileElement->type = TILE_ELEMENT_TYPE_TRACK;
|
||||
tileElement->properties.track.type = TRACK_ELEM_MAZE;
|
||||
tileElement->properties.track.ride_index = rideIndex;
|
||||
tileElement->properties.track.maze_entry = mazeEntry;
|
||||
if (flags & GAME_COMMAND_FLAG_GHOST)
|
||||
{
|
||||
mapElement->flags |= TILE_ELEMENT_FLAG_GHOST;
|
||||
tileElement->flags |= TILE_ELEMENT_FLAG_GHOST;
|
||||
}
|
||||
|
||||
map_invalidate_element(fx, fy, mapElement);
|
||||
map_invalidate_element(fx, fy, tileElement);
|
||||
|
||||
ride->maze_tiles++;
|
||||
ride->station_heights[0] = mapElement->base_height;
|
||||
ride->station_heights[0] = tileElement->base_height;
|
||||
ride->station_starts[0].xy = 0;
|
||||
if (ride->maze_tiles == 1)
|
||||
{
|
||||
|
@ -2286,15 +2286,15 @@ static map_backup * track_design_preview_backup_map()
|
|||
{
|
||||
memcpy(
|
||||
backup->tile_elements,
|
||||
gMapElements,
|
||||
gTileElements,
|
||||
sizeof(backup->tile_elements)
|
||||
);
|
||||
memcpy(
|
||||
backup->tile_pointers,
|
||||
gMapElementTilePointers,
|
||||
gTileElementTilePointers,
|
||||
sizeof(backup->tile_pointers)
|
||||
);
|
||||
backup->next_free_tile_element = gNextFreeMapElement;
|
||||
backup->next_free_tile_element = gNextFreeTileElement;
|
||||
backup->map_size_units = gMapSizeUnits;
|
||||
backup->map_size_units_minus_2 = gMapSizeMinus2;
|
||||
backup->map_size = gMapSize;
|
||||
|
@ -2310,16 +2310,16 @@ static map_backup * track_design_preview_backup_map()
|
|||
static void track_design_preview_restore_map(map_backup * backup)
|
||||
{
|
||||
memcpy(
|
||||
gMapElements,
|
||||
gTileElements,
|
||||
backup->tile_elements,
|
||||
sizeof(backup->tile_elements)
|
||||
);
|
||||
memcpy(
|
||||
gMapElementTilePointers,
|
||||
gTileElementTilePointers,
|
||||
backup->tile_pointers,
|
||||
sizeof(backup->tile_pointers)
|
||||
);
|
||||
gNextFreeMapElement = backup->next_free_tile_element;
|
||||
gNextFreeTileElement = backup->next_free_tile_element;
|
||||
gMapSizeUnits = backup->map_size_units;
|
||||
gMapSizeMinus2 = backup->map_size_units_minus_2;
|
||||
gMapSize = backup->map_size;
|
||||
|
@ -2342,7 +2342,7 @@ static void track_design_preview_clear_map()
|
|||
|
||||
for (sint32 i = 0; i < MAX_TILE_TILE_ELEMENT_POINTERS; i++)
|
||||
{
|
||||
rct_tile_element * tile_element = &gMapElements[i];
|
||||
rct_tile_element * tile_element = &gTileElements[i];
|
||||
tile_element->type = TILE_ELEMENT_TYPE_SURFACE;
|
||||
tile_element->flags = TILE_ELEMENT_FLAG_LAST_TILE;
|
||||
tile_element->base_height = 2;
|
||||
|
|
|
@ -232,9 +232,9 @@ void track_design_draw_preview(rct_track_td6 *td6, uint8 *pixels);
|
|||
///////////////////////////////////////////////////////////////////////////////
|
||||
void track_design_save_init();
|
||||
void track_design_save_reset_scenery();
|
||||
bool track_design_save_contains_tile_element(rct_tile_element *mapElement);
|
||||
bool track_design_save_contains_tile_element(rct_tile_element *tileElement);
|
||||
void track_design_save_select_nearby_scenery(sint32 rideIndex);
|
||||
void track_design_save_select_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *mapElement, bool collect);
|
||||
void track_design_save_select_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *tileElement, bool collect);
|
||||
bool track_design_save(uint8 rideIndex);
|
||||
bool track_design_save_to_file(const utf8 *path);
|
||||
|
||||
|
|
|
@ -2729,15 +2729,15 @@ static bool try_add_synchronised_station(sint32 x, sint32 y, sint32 z)
|
|||
return false;
|
||||
}
|
||||
|
||||
rct_tile_element * mapElement = get_station_platform(x, y, z, 2);
|
||||
if (mapElement == NULL)
|
||||
rct_tile_element * tileElement = get_station_platform(x, y, z, 2);
|
||||
if (tileElement == NULL)
|
||||
{
|
||||
/* No station platform element found,
|
||||
* so no station to synchronise */
|
||||
return false;
|
||||
}
|
||||
|
||||
sint32 rideIndex = mapElement->properties.track.ride_index;
|
||||
sint32 rideIndex = tileElement->properties.track.ride_index;
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
if (!(ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS))
|
||||
{
|
||||
|
@ -2749,7 +2749,7 @@ static bool try_add_synchronised_station(sint32 x, sint32 y, sint32 z)
|
|||
* to sync with adjacent stations, so it will return true.
|
||||
* Still to determine if a vehicle to sync can be identified. */
|
||||
|
||||
sint32 stationIndex = tile_element_get_station(mapElement);
|
||||
sint32 stationIndex = tile_element_get_station(tileElement);
|
||||
|
||||
rct_synchronised_vehicle * sv = _lastSynchronisedVehicle;
|
||||
sv->ride_id = rideIndex;
|
||||
|
@ -2829,8 +2829,8 @@ static bool vehicle_can_depart_synchronised(rct_vehicle * vehicle)
|
|||
sint32 y = location.y * 32;
|
||||
sint32 z = ride->station_heights[station];
|
||||
|
||||
rct_tile_element * mapElement = map_get_track_element_at(x, y, z);
|
||||
if (mapElement == NULL)
|
||||
rct_tile_element * tileElement = map_get_track_element_at(x, y, z);
|
||||
if (tileElement == NULL)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -2843,7 +2843,7 @@ static bool vehicle_can_depart_synchronised(rct_vehicle * vehicle)
|
|||
* is found we allow for space between that and the next.
|
||||
*/
|
||||
|
||||
sint32 direction = (mapElement->type + 1) & 3;
|
||||
sint32 direction = (tileElement->type + 1) & 3;
|
||||
sint32 spaceBetween;
|
||||
sint32 maxCheckDistance = RIDE_ADJACENCY_CHECK_DISTANCE;
|
||||
|
||||
|
@ -3113,33 +3113,33 @@ void vehicle_test_reset(rct_vehicle * vehicle)
|
|||
|
||||
static bool vehicle_next_tower_element_is_top(rct_vehicle * vehicle)
|
||||
{
|
||||
rct_tile_element * mapElement =
|
||||
rct_tile_element * tileElement =
|
||||
map_get_track_element_at_of_type(vehicle->track_x, vehicle->track_y, vehicle->track_z / 8, vehicle->track_type >> 2);
|
||||
|
||||
if (mapElement->flags & TILE_ELEMENT_FLAG_LAST_TILE)
|
||||
if (tileElement->flags & TILE_ELEMENT_FLAG_LAST_TILE)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
if (mapElement->clearance_height == (mapElement + 1)->base_height)
|
||||
if (tileElement->clearance_height == (tileElement + 1)->base_height)
|
||||
{
|
||||
if ((mapElement + 1)->properties.track.type == TRACK_ELEM_TOWER_SECTION)
|
||||
if ((tileElement + 1)->properties.track.type == TRACK_ELEM_TOWER_SECTION)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if ((mapElement + 1)->flags & TILE_ELEMENT_FLAG_LAST_TILE)
|
||||
if ((tileElement + 1)->flags & TILE_ELEMENT_FLAG_LAST_TILE)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
if (mapElement->clearance_height != (mapElement + 2)->base_height)
|
||||
if (tileElement->clearance_height != (tileElement + 2)->base_height)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
if ((mapElement + 2)->properties.track.type == TRACK_ELEM_TOWER_SECTION)
|
||||
if ((tileElement + 2)->properties.track.type == TRACK_ELEM_TOWER_SECTION)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -3991,14 +3991,14 @@ loc_6D8E36:
|
|||
return;
|
||||
}
|
||||
|
||||
rct_tile_element * mapElement = map_get_track_element_at(vehicle->track_x, vehicle->track_y, vehicle->track_z / 8);
|
||||
rct_tile_element * tileElement = map_get_track_element_at(vehicle->track_x, vehicle->track_y, vehicle->track_z / 8);
|
||||
|
||||
if (mapElement == NULL)
|
||||
if (tileElement == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
vehicle->current_station = tile_element_get_station(mapElement);
|
||||
vehicle->current_station = tile_element_get_station(tileElement);
|
||||
vehicle->num_laps++;
|
||||
|
||||
if (vehicle->sub_state != 0)
|
||||
|
@ -4278,10 +4278,10 @@ static void loc_6DA9F9(rct_vehicle * vehicle, sint32 x, sint32 y, sint32 bx, sin
|
|||
vehicle->track_x = bx;
|
||||
vehicle->track_y = dx;
|
||||
|
||||
rct_tile_element * mapElement = map_get_track_element_at(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3);
|
||||
rct_tile_element * tileElement = map_get_track_element_at(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3);
|
||||
|
||||
Ride * ride = get_ride(vehicle->ride);
|
||||
vehicle->track_type = (mapElement->properties.track.type << 2) | (ride->boat_hire_return_direction & 3);
|
||||
vehicle->track_type = (tileElement->properties.track.type << 2) | (ride->boat_hire_return_direction & 3);
|
||||
|
||||
vehicle->track_progress = 0;
|
||||
vehicle->status = VEHICLE_STATUS_TRAVELLING;
|
||||
|
@ -4657,12 +4657,12 @@ static void vehicle_update_boat_location(rct_vehicle * vehicle)
|
|||
static bool vehicle_is_boat_on_water(rct_vehicle * vehicle, sint32 x, sint32 y)
|
||||
{
|
||||
sint32 z = vehicle->track_z >> 3;
|
||||
rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
do
|
||||
{
|
||||
if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SURFACE)
|
||||
if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
|
||||
{
|
||||
sint32 waterZ = map_get_water_height(mapElement) * 2;
|
||||
sint32 waterZ = map_get_water_height(tileElement) * 2;
|
||||
if (z != waterZ)
|
||||
{
|
||||
return true;
|
||||
|
@ -4670,12 +4670,12 @@ static bool vehicle_is_boat_on_water(rct_vehicle * vehicle, sint32 x, sint32 y)
|
|||
}
|
||||
else
|
||||
{
|
||||
if (z > mapElement->base_height - 2 && z < mapElement->clearance_height + 2)
|
||||
if (z > tileElement->base_height - 2 && z < tileElement->clearance_height + 2)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -5157,8 +5157,8 @@ static void vehicle_update_doing_circus_show(rct_vehicle * vehicle)
|
|||
*/
|
||||
static rct_tile_element * vehicle_check_collision(sint16 x, sint16 y, sint16 z)
|
||||
{
|
||||
rct_tile_element * mapElement = map_get_first_element_at(x / 32, y / 32);
|
||||
if (mapElement == NULL)
|
||||
rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
|
||||
if (tileElement == NULL)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
@ -5179,15 +5179,15 @@ static rct_tile_element * vehicle_check_collision(sint16 x, sint16 y, sint16 z)
|
|||
|
||||
do
|
||||
{
|
||||
if (z / 8 < mapElement->base_height)
|
||||
if (z / 8 < tileElement->base_height)
|
||||
continue;
|
||||
|
||||
if (z / 8 >= mapElement->clearance_height)
|
||||
if (z / 8 >= tileElement->clearance_height)
|
||||
continue;
|
||||
|
||||
if (mapElement->flags & bl)
|
||||
return mapElement;
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
if (tileElement->flags & bl)
|
||||
return tileElement;
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
@ -6719,24 +6719,24 @@ static void update_velocity(rct_vehicle * vehicle)
|
|||
_vehicleVelocityF64E0C = (nextVelocity >> 10) * 42;
|
||||
}
|
||||
|
||||
static void vehicle_update_block_brakes_open_previous_section(rct_vehicle * vehicle, rct_tile_element * mapElement)
|
||||
static void vehicle_update_block_brakes_open_previous_section(rct_vehicle * vehicle, rct_tile_element * tileElement)
|
||||
{
|
||||
sint32 x = vehicle->track_x;
|
||||
sint32 y = vehicle->track_y;
|
||||
sint32 z = vehicle->track_z;
|
||||
track_begin_end trackBeginEnd, slowTrackBeginEnd;
|
||||
rct_tile_element slowMapElement = *mapElement;
|
||||
rct_tile_element slowTileElement = *tileElement;
|
||||
bool counter = true;
|
||||
sint32 slowX = x;
|
||||
sint32 slowY = y;
|
||||
do
|
||||
{
|
||||
if (!track_block_get_previous(x, y, mapElement, &trackBeginEnd))
|
||||
if (!track_block_get_previous(x, y, tileElement, &trackBeginEnd))
|
||||
{
|
||||
return;
|
||||
}
|
||||
if (trackBeginEnd.begin_x == vehicle->track_x && trackBeginEnd.begin_y == vehicle->track_y &&
|
||||
mapElement == trackBeginEnd.begin_element)
|
||||
tileElement == trackBeginEnd.begin_element)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
@ -6744,18 +6744,18 @@ static void vehicle_update_block_brakes_open_previous_section(rct_vehicle * vehi
|
|||
x = trackBeginEnd.end_x;
|
||||
y = trackBeginEnd.end_y;
|
||||
z = trackBeginEnd.begin_z;
|
||||
mapElement = trackBeginEnd.begin_element;
|
||||
tileElement = trackBeginEnd.begin_element;
|
||||
|
||||
//#2081: prevent infinite loop
|
||||
counter = !counter;
|
||||
if (counter)
|
||||
{
|
||||
track_block_get_previous(slowX, slowY, &slowMapElement, &slowTrackBeginEnd);
|
||||
track_block_get_previous(slowX, slowY, &slowTileElement, &slowTrackBeginEnd);
|
||||
slowX = slowTrackBeginEnd.end_x;
|
||||
slowY = slowTrackBeginEnd.end_y;
|
||||
slowMapElement = *(slowTrackBeginEnd.begin_element);
|
||||
if (slowX == x && slowY == y && slowMapElement.base_height == mapElement->base_height &&
|
||||
slowMapElement.type == mapElement->type)
|
||||
slowTileElement = *(slowTrackBeginEnd.begin_element);
|
||||
if (slowX == x && slowY == y && slowTileElement.base_height == tileElement->base_height &&
|
||||
slowTileElement.type == tileElement->type)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
@ -6766,15 +6766,15 @@ static void vehicle_update_block_brakes_open_previous_section(rct_vehicle * vehi
|
|||
x = trackBeginEnd.begin_x;
|
||||
y = trackBeginEnd.begin_y;
|
||||
z = trackBeginEnd.begin_z;
|
||||
mapElement = map_get_track_element_at(x, y, z >> 3);
|
||||
if (mapElement == NULL)
|
||||
tileElement = map_get_track_element_at(x, y, z >> 3);
|
||||
if (tileElement == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
mapElement->flags &= ~TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
|
||||
map_invalidate_element(x, y, mapElement);
|
||||
tileElement->flags &= ~TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
|
||||
map_invalidate_element(x, y, tileElement);
|
||||
|
||||
sint32 trackType = mapElement->properties.track.type;
|
||||
sint32 trackType = tileElement->properties.track.type;
|
||||
if (trackType == TRACK_ELEM_BLOCK_BRAKES || trackType == TRACK_ELEM_END_STATION)
|
||||
{
|
||||
Ride * ride = get_ride(vehicle->ride);
|
||||
|
@ -7198,8 +7198,8 @@ static void vehicle_update_spinning_car(rct_vehicle * vehicle)
|
|||
*/
|
||||
static void steam_particle_create(sint16 x, sint16 y, sint16 z)
|
||||
{
|
||||
rct_tile_element * mapElement = map_get_surface_element_at(x >> 5, y >> 5);
|
||||
if (mapElement != NULL && z > mapElement->base_height * 8)
|
||||
rct_tile_element * tileElement = map_get_surface_element_at(x >> 5, y >> 5);
|
||||
if (tileElement != NULL && z > tileElement->base_height * 8)
|
||||
{
|
||||
rct_steam_particle * steam = (rct_steam_particle *)create_sprite(2);
|
||||
if (steam == NULL)
|
||||
|
@ -7364,9 +7364,9 @@ static void sub_6D63D4(rct_vehicle * vehicle)
|
|||
*
|
||||
* rct2: 0x006DEDB1
|
||||
*/
|
||||
static void vehicle_play_scenery_door_open_sound(rct_vehicle * vehicle, rct_tile_element * mapElement)
|
||||
static void vehicle_play_scenery_door_open_sound(rct_vehicle * vehicle, rct_tile_element * tileElement)
|
||||
{
|
||||
rct_scenery_entry * wallEntry = get_wall_entry(mapElement->properties.wall.type);
|
||||
rct_scenery_entry * wallEntry = get_wall_entry(tileElement->properties.wall.type);
|
||||
sint32 doorSoundType = (wallEntry->wall.flags2 >> 1) & 3;
|
||||
if (doorSoundType != 0)
|
||||
{
|
||||
|
@ -7382,9 +7382,9 @@ static void vehicle_play_scenery_door_open_sound(rct_vehicle * vehicle, rct_tile
|
|||
*
|
||||
* rct2: 0x006DED7A
|
||||
*/
|
||||
static void vehicle_play_scenery_door_close_sound(rct_vehicle * vehicle, rct_tile_element * mapElement)
|
||||
static void vehicle_play_scenery_door_close_sound(rct_vehicle * vehicle, rct_tile_element * tileElement)
|
||||
{
|
||||
rct_scenery_entry * wallEntry = get_wall_entry(mapElement->properties.wall.type);
|
||||
rct_scenery_entry * wallEntry = get_wall_entry(tileElement->properties.wall.type);
|
||||
sint32 doorSoundType = (wallEntry->wall.flags2 >> 1) & 3;
|
||||
if (doorSoundType != 0)
|
||||
{
|
||||
|
@ -7414,24 +7414,24 @@ static void vehicle_update_scenery_door(rct_vehicle * vehicle)
|
|||
sint32 z = (vehicle->track_z - trackBlock->z + trackCoordinates->z_end) >> 3;
|
||||
sint32 direction = (vehicle->track_direction + trackCoordinates->rotation_end) & 3;
|
||||
|
||||
rct_tile_element * mapElement = map_get_wall_element_at(x, y, z, direction);
|
||||
if (mapElement == NULL)
|
||||
rct_tile_element * tileElement = map_get_wall_element_at(x, y, z, direction);
|
||||
if (tileElement == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (vehicle->next_vehicle_on_train != SPRITE_INDEX_NULL)
|
||||
{
|
||||
mapElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
|
||||
wall_element_set_animation_frame(mapElement, 1);
|
||||
tileElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
|
||||
wall_element_set_animation_frame(tileElement, 1);
|
||||
map_animation_create(MAP_ANIMATION_TYPE_WALL_DOOR, x, y, z);
|
||||
vehicle_play_scenery_door_open_sound(vehicle, mapElement);
|
||||
vehicle_play_scenery_door_open_sound(vehicle, tileElement);
|
||||
}
|
||||
else
|
||||
{
|
||||
mapElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
|
||||
wall_element_set_animation_frame(mapElement, 6);
|
||||
vehicle_play_scenery_door_close_sound(vehicle, mapElement);
|
||||
tileElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
|
||||
wall_element_set_animation_frame(tileElement, 6);
|
||||
vehicle_play_scenery_door_close_sound(vehicle, tileElement);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -7439,13 +7439,13 @@ static void vehicle_update_scenery_door(rct_vehicle * vehicle)
|
|||
*
|
||||
* rct2: 0x006DB38B
|
||||
*/
|
||||
static bool loc_6DB38B(rct_vehicle * vehicle, rct_tile_element * mapElement)
|
||||
static bool loc_6DB38B(rct_vehicle * vehicle, rct_tile_element * tileElement)
|
||||
{
|
||||
// Get bank
|
||||
sint32 bankStart = track_get_actual_bank_3(vehicle, mapElement);
|
||||
sint32 bankStart = track_get_actual_bank_3(vehicle, tileElement);
|
||||
|
||||
// Get vangle
|
||||
sint32 trackType = mapElement->properties.track.type;
|
||||
sint32 trackType = tileElement->properties.track.type;
|
||||
sint32 vangleStart = TrackDefinitions[trackType].vangle_start;
|
||||
|
||||
if (vangleStart != _vehicleVAngleEndF64E36 || bankStart != _vehicleBankEndF64E37)
|
||||
|
@ -7477,11 +7477,11 @@ static void loc_6DB481(rct_vehicle * vehicle)
|
|||
*
|
||||
* rct2: 0x006DB545
|
||||
*/
|
||||
static void vehicle_trigger_on_ride_photo(rct_vehicle * vehicle, rct_tile_element * mapElement)
|
||||
static void vehicle_trigger_on_ride_photo(rct_vehicle * vehicle, rct_tile_element * tileElement)
|
||||
{
|
||||
tile_element_set_onride_photo_timeout(mapElement);
|
||||
tile_element_set_onride_photo_timeout(tileElement);
|
||||
|
||||
map_animation_create(MAP_ANIMATION_TYPE_TRACK_ONRIDEPHOTO, vehicle->track_x, vehicle->track_y, mapElement->base_height);
|
||||
map_animation_create(MAP_ANIMATION_TYPE_TRACK_ONRIDEPHOTO, vehicle->track_x, vehicle->track_y, tileElement->base_height);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -7499,24 +7499,24 @@ static void vehicle_update_handle_scenery_door(rct_vehicle * vehicle)
|
|||
sint32 direction = (vehicle->track_direction + trackCoordinates->rotation_begin) & 3;
|
||||
direction ^= 2;
|
||||
|
||||
rct_tile_element * mapElement = map_get_wall_element_at(x, y, z, direction);
|
||||
if (mapElement == NULL)
|
||||
rct_tile_element * tileElement = map_get_wall_element_at(x, y, z, direction);
|
||||
if (tileElement == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (vehicle->next_vehicle_on_train != SPRITE_INDEX_NULL)
|
||||
{
|
||||
mapElement->properties.wall.animation |= WALL_ANIMATION_FLAG_DIRECTION_BACKWARD;
|
||||
wall_element_set_animation_frame(mapElement, 1);
|
||||
tileElement->properties.wall.animation |= WALL_ANIMATION_FLAG_DIRECTION_BACKWARD;
|
||||
wall_element_set_animation_frame(tileElement, 1);
|
||||
map_animation_create(MAP_ANIMATION_TYPE_WALL_DOOR, x, y, z);
|
||||
vehicle_play_scenery_door_open_sound(vehicle, mapElement);
|
||||
vehicle_play_scenery_door_open_sound(vehicle, tileElement);
|
||||
}
|
||||
else
|
||||
{
|
||||
mapElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
|
||||
wall_element_set_animation_frame(mapElement, 6);
|
||||
vehicle_play_scenery_door_close_sound(vehicle, mapElement);
|
||||
tileElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
|
||||
wall_element_set_animation_frame(tileElement, 6);
|
||||
vehicle_play_scenery_door_close_sound(vehicle, tileElement);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -7837,21 +7837,21 @@ static void sub_6DBF3E(rct_vehicle * vehicle)
|
|||
|
||||
_vehicleMotionTrackFlags |= VEHICLE_UPDATE_MOTION_TRACK_FLAG_3;
|
||||
|
||||
rct_tile_element * mapElement = NULL;
|
||||
rct_tile_element * tileElement = NULL;
|
||||
if (map_is_location_valid(vehicle->track_x, vehicle->track_y))
|
||||
{
|
||||
mapElement =
|
||||
tileElement =
|
||||
map_get_track_element_at_of_type_seq(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3, trackType, 0);
|
||||
}
|
||||
|
||||
if (mapElement == NULL)
|
||||
if (tileElement == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (_vehicleStationIndex == 0xFF)
|
||||
{
|
||||
_vehicleStationIndex = tile_element_get_station(mapElement);
|
||||
_vehicleStationIndex = tile_element_get_station(tileElement);
|
||||
}
|
||||
|
||||
if (trackType == TRACK_ELEM_TOWER_BASE && vehicle == gCurrentVehicle)
|
||||
|
@ -7863,7 +7863,7 @@ static void sub_6DBF3E(rct_vehicle * vehicle)
|
|||
|
||||
input.x = vehicle->track_x;
|
||||
input.y = vehicle->track_y;
|
||||
input.element = mapElement;
|
||||
input.element = tileElement;
|
||||
if (!track_block_get_next(&input, &output, &outputZ, &outputDirection))
|
||||
{
|
||||
_vehicleMotionTrackFlags |= VEHICLE_UPDATE_MOTION_TRACK_FLAG_12;
|
||||
|
@ -7919,10 +7919,10 @@ static bool vehicle_update_track_motion_forwards_get_new_track(rct_vehicle * veh
|
|||
|
||||
_vehicleVAngleEndF64E36 = TrackDefinitions[trackType].vangle_end;
|
||||
_vehicleBankEndF64E37 = TrackDefinitions[trackType].bank_end;
|
||||
rct_tile_element * mapElement =
|
||||
rct_tile_element * tileElement =
|
||||
map_get_track_element_at_of_type_seq(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3, trackType, 0);
|
||||
|
||||
if (mapElement == NULL)
|
||||
if (tileElement == NULL)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -7932,11 +7932,11 @@ static bool vehicle_update_track_motion_forwards_get_new_track(rct_vehicle * veh
|
|||
_vehicleMotionTrackFlags |= VEHICLE_UPDATE_MOTION_TRACK_FLAG_11;
|
||||
}
|
||||
|
||||
if (track_element_is_block_start(mapElement))
|
||||
if (track_element_is_block_start(tileElement))
|
||||
{
|
||||
if (vehicle->next_vehicle_on_train == SPRITE_INDEX_NULL)
|
||||
{
|
||||
mapElement->flags |= TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
|
||||
tileElement->flags |= TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
|
||||
if (trackType == TRACK_ELEM_BLOCK_BRAKES || trackType == TRACK_ELEM_END_STATION)
|
||||
{
|
||||
if (!(rideEntry->vehicles[0].flags & VEHICLE_ENTRY_FLAG_POWERED))
|
||||
|
@ -7944,8 +7944,8 @@ static bool vehicle_update_track_motion_forwards_get_new_track(rct_vehicle * veh
|
|||
audio_play_sound_at_location(SOUND_49, vehicle->track_x, vehicle->track_y, vehicle->track_z);
|
||||
}
|
||||
}
|
||||
map_invalidate_element(vehicle->track_x, vehicle->track_z, mapElement);
|
||||
vehicle_update_block_brakes_open_previous_section(vehicle, mapElement);
|
||||
map_invalidate_element(vehicle->track_x, vehicle->track_z, tileElement);
|
||||
vehicle_update_block_brakes_open_previous_section(vehicle, tileElement);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -7974,7 +7974,7 @@ static bool vehicle_update_track_motion_forwards_get_new_track(rct_vehicle * veh
|
|||
loc_6DB32A:
|
||||
{
|
||||
track_begin_end trackBeginEnd;
|
||||
if (!track_block_get_previous(vehicle->track_x, vehicle->track_y, mapElement, &trackBeginEnd))
|
||||
if (!track_block_get_previous(vehicle->track_x, vehicle->track_y, tileElement, &trackBeginEnd))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -7982,7 +7982,7 @@ loc_6DB32A:
|
|||
regs.ecx = trackBeginEnd.begin_y;
|
||||
regs.edx = trackBeginEnd.begin_z;
|
||||
regs.bl = trackBeginEnd.begin_direction;
|
||||
mapElement = trackBeginEnd.begin_element;
|
||||
tileElement = trackBeginEnd.begin_element;
|
||||
}
|
||||
goto loc_6DB41D;
|
||||
|
||||
|
@ -7992,19 +7992,19 @@ loc_6DB358:
|
|||
sint32 z, direction;
|
||||
xyElement.x = vehicle->track_x;
|
||||
xyElement.y = vehicle->track_y;
|
||||
xyElement.element = mapElement;
|
||||
xyElement.element = tileElement;
|
||||
if (!track_block_get_next(&xyElement, &xyElement, &z, &direction))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
mapElement = xyElement.element;
|
||||
tileElement = xyElement.element;
|
||||
regs.eax = xyElement.x;
|
||||
regs.ecx = xyElement.y;
|
||||
regs.edx = z;
|
||||
regs.bl = direction;
|
||||
}
|
||||
if (mapElement->properties.track.type == TRACK_ELEM_LEFT_REVERSER ||
|
||||
mapElement->properties.track.type == TRACK_ELEM_RIGHT_REVERSER)
|
||||
if (tileElement->properties.track.type == TRACK_ELEM_LEFT_REVERSER ||
|
||||
tileElement->properties.track.type == TRACK_ELEM_RIGHT_REVERSER)
|
||||
{
|
||||
if (!vehicle->is_child && vehicle->velocity <= 0x30000)
|
||||
{
|
||||
|
@ -8012,7 +8012,7 @@ loc_6DB358:
|
|||
}
|
||||
}
|
||||
|
||||
if (!loc_6DB38B(vehicle, mapElement))
|
||||
if (!loc_6DB38B(vehicle, tileElement))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -8020,10 +8020,10 @@ loc_6DB358:
|
|||
// Update VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES flag
|
||||
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
|
||||
{
|
||||
sint32 rideType = get_ride(mapElement->properties.track.ride_index)->type;
|
||||
sint32 rideType = get_ride(tileElement->properties.track.ride_index)->type;
|
||||
if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_HAS_ALTERNATIVE_TRACK_TYPE)
|
||||
{
|
||||
if (track_element_is_inverted(mapElement))
|
||||
if (track_element_is_inverted(tileElement))
|
||||
{
|
||||
vehicle->update_flags |= VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
|
||||
}
|
||||
|
@ -8040,14 +8040,14 @@ loc_6DB41D:
|
|||
|
||||
if ((vehicleEntry->flags & VEHICLE_ENTRY_FLAG_30) && vehicle->var_CD < 7)
|
||||
{
|
||||
trackType = mapElement->properties.track.type;
|
||||
trackType = tileElement->properties.track.type;
|
||||
if (trackType == TRACK_ELEM_FLAT)
|
||||
{
|
||||
loc_6DB481(vehicle);
|
||||
}
|
||||
else if (ride->lifecycle_flags & RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING)
|
||||
{
|
||||
if (track_element_is_station(mapElement))
|
||||
if (track_element_is_station(tileElement))
|
||||
{
|
||||
loc_6DB481(vehicle);
|
||||
}
|
||||
|
@ -8072,25 +8072,25 @@ loc_6DB41D:
|
|||
// loc_6DB500
|
||||
// Update VEHICLE_UPDATE_FLAG_0
|
||||
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_0;
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
vehicle->update_flags |= VEHICLE_UPDATE_FLAG_0;
|
||||
}
|
||||
|
||||
trackType = mapElement->properties.track.type;
|
||||
trackType = tileElement->properties.track.type;
|
||||
if (trackType != TRACK_ELEM_BRAKES)
|
||||
{
|
||||
vehicle->target_seat_rotation = track_element_get_seat_rotation(mapElement);
|
||||
vehicle->target_seat_rotation = track_element_get_seat_rotation(tileElement);
|
||||
}
|
||||
vehicle->track_direction = regs.bl & 3;
|
||||
vehicle->track_type |= trackType << 2;
|
||||
vehicle->brake_speed = tile_element_get_brake_booster_speed(mapElement);
|
||||
vehicle->brake_speed = tile_element_get_brake_booster_speed(tileElement);
|
||||
if (trackType == TRACK_ELEM_ON_RIDE_PHOTO)
|
||||
{
|
||||
vehicle_trigger_on_ride_photo(vehicle, mapElement);
|
||||
vehicle_trigger_on_ride_photo(vehicle, tileElement);
|
||||
}
|
||||
{
|
||||
uint16 rideType = get_ride(mapElement->properties.track.ride_index)->type;
|
||||
uint16 rideType = get_ride(tileElement->properties.track.ride_index)->type;
|
||||
if (trackType == TRACK_ELEM_ROTATION_CONTROL_TOGGLE && rideType == RIDE_TYPE_WILD_MOUSE)
|
||||
{
|
||||
vehicle->update_flags ^= VEHICLE_UPDATE_FLAG_13;
|
||||
|
@ -8352,10 +8352,10 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
|
|||
{
|
||||
_vehicleVAngleEndF64E36 = TrackDefinitions[trackType].vangle_start;
|
||||
_vehicleBankEndF64E37 = TrackDefinitions[trackType].bank_start;
|
||||
rct_tile_element * mapElement =
|
||||
rct_tile_element * tileElement =
|
||||
map_get_track_element_at_of_type_seq(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3, trackType, 0);
|
||||
|
||||
if (mapElement == NULL)
|
||||
if (tileElement == NULL)
|
||||
return false;
|
||||
|
||||
bool nextTileBackwards = true;
|
||||
|
@ -8387,19 +8387,19 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
|
|||
{
|
||||
// loc_6DBB7E:;
|
||||
track_begin_end trackBeginEnd;
|
||||
if (!track_block_get_previous(x, y, mapElement, &trackBeginEnd))
|
||||
if (!track_block_get_previous(x, y, tileElement, &trackBeginEnd))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
mapElement = trackBeginEnd.begin_element;
|
||||
tileElement = trackBeginEnd.begin_element;
|
||||
|
||||
trackType = mapElement->properties.track.type;
|
||||
trackType = tileElement->properties.track.type;
|
||||
if (trackType == TRACK_ELEM_LEFT_REVERSER || trackType == TRACK_ELEM_RIGHT_REVERSER)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
sint32 trackColour = ((vehicle->update_flags >> 9) ^ mapElement->properties.track.colour) & 4;
|
||||
sint32 trackColour = ((vehicle->update_flags >> 9) ^ tileElement->properties.track.colour) & 4;
|
||||
sint32 bank = TrackDefinitions[trackType].bank_end;
|
||||
bank = track_get_actual_bank_2(ride->type, trackColour, bank);
|
||||
sint32 vAngle = TrackDefinitions[trackType].vangle_end;
|
||||
|
@ -8412,7 +8412,7 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
|
|||
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
|
||||
if (RideData4[ride->type].flags & RIDE_TYPE_FLAG4_HAS_ALTERNATIVE_TRACK_TYPE)
|
||||
{
|
||||
if (track_element_is_inverted(mapElement))
|
||||
if (track_element_is_inverted(tileElement))
|
||||
{
|
||||
vehicle->update_flags |= VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
|
||||
}
|
||||
|
@ -8432,12 +8432,12 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
|
|||
|
||||
input.x = x;
|
||||
input.y = y;
|
||||
input.element = mapElement;
|
||||
input.element = tileElement;
|
||||
if (!track_block_get_next(&input, &output, &outputZ, &direction))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
mapElement = output.element;
|
||||
tileElement = output.element;
|
||||
x = output.x;
|
||||
y = output.y;
|
||||
z = outputZ;
|
||||
|
@ -8462,13 +8462,13 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
|
|||
}
|
||||
}
|
||||
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
if (_vehicleVelocityF64E08 < 0)
|
||||
{
|
||||
if (vehicle->next_vehicle_on_train == SPRITE_INDEX_NULL)
|
||||
{
|
||||
trackType = mapElement->properties.track.type;
|
||||
trackType = tileElement->properties.track.type;
|
||||
if (!(TrackFlags[trackType] & TRACK_ELEM_FLAG_DOWN))
|
||||
{
|
||||
_vehicleMotionTrackFlags |= VEHICLE_UPDATE_MOTION_TRACK_FLAG_9;
|
||||
|
@ -8492,15 +8492,15 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
|
|||
}
|
||||
}
|
||||
|
||||
trackType = mapElement->properties.track.type;
|
||||
trackType = tileElement->properties.track.type;
|
||||
if (trackType != TRACK_ELEM_BRAKES)
|
||||
{
|
||||
vehicle->target_seat_rotation = track_element_get_seat_rotation(mapElement);
|
||||
vehicle->target_seat_rotation = track_element_get_seat_rotation(tileElement);
|
||||
}
|
||||
direction &= 3;
|
||||
vehicle->track_type = trackType << 2;
|
||||
vehicle->track_direction |= direction;
|
||||
vehicle->brake_speed = tile_element_get_brake_booster_speed(mapElement);
|
||||
vehicle->brake_speed = tile_element_get_brake_booster_speed(tileElement);
|
||||
|
||||
// There are two bytes before the move info list
|
||||
uint16 trackTotalProgress = vehicle_get_move_info_size(vehicle->var_CD, vehicle->track_type);
|
||||
|
@ -8678,7 +8678,7 @@ static sint32 vehicle_update_track_motion_mini_golf(rct_vehicle * vehicle, sint3
|
|||
rct_ride_entry * rideEntry = get_ride_entry(vehicle->ride_subtype);
|
||||
rct_ride_entry_vehicle * vehicleEntry = vehicle_get_vehicle_entry(vehicle);
|
||||
|
||||
rct_tile_element * mapElement = NULL;
|
||||
rct_tile_element * tileElement = NULL;
|
||||
|
||||
gCurrentVehicle = vehicle;
|
||||
_vehicleMotionTrackFlags = 0;
|
||||
|
@ -8811,7 +8811,7 @@ loc_6DC476:
|
|||
uint16 trackType = vehicle->track_type >> 2;
|
||||
_vehicleVAngleEndF64E36 = TrackDefinitions[trackType].vangle_end;
|
||||
_vehicleBankEndF64E37 = TrackDefinitions[trackType].bank_end;
|
||||
mapElement =
|
||||
tileElement =
|
||||
map_get_track_element_at_of_type_seq(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3, trackType, 0);
|
||||
}
|
||||
sint16 x, y, z;
|
||||
|
@ -8821,29 +8821,29 @@ loc_6DC476:
|
|||
sint32 outZ, outDirection;
|
||||
input.x = vehicle->track_x;
|
||||
input.y = vehicle->track_y;
|
||||
input.element = mapElement;
|
||||
input.element = tileElement;
|
||||
if (!track_block_get_next(&input, &output, &outZ, &outDirection))
|
||||
{
|
||||
goto loc_6DC9BC;
|
||||
}
|
||||
mapElement = output.element;
|
||||
tileElement = output.element;
|
||||
x = output.x;
|
||||
y = output.y;
|
||||
z = outZ;
|
||||
direction = outDirection;
|
||||
}
|
||||
|
||||
if (!loc_6DB38B(vehicle, mapElement))
|
||||
if (!loc_6DB38B(vehicle, tileElement))
|
||||
{
|
||||
goto loc_6DC9BC;
|
||||
}
|
||||
|
||||
{
|
||||
sint32 rideType = get_ride(mapElement->properties.track.ride_index)->type;
|
||||
sint32 rideType = get_ride(tileElement->properties.track.ride_index)->type;
|
||||
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
|
||||
if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_HAS_ALTERNATIVE_TRACK_TYPE)
|
||||
{
|
||||
if (track_element_is_inverted(mapElement))
|
||||
if (track_element_is_inverted(tileElement))
|
||||
{
|
||||
vehicle->update_flags |= VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
|
||||
}
|
||||
|
@ -8866,8 +8866,8 @@ loc_6DC476:
|
|||
}
|
||||
|
||||
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_0;
|
||||
vehicle->track_type = (mapElement->properties.track.type << 2) | (direction & 3);
|
||||
vehicle->var_CF = tile_element_get_brake_booster_speed(mapElement);
|
||||
vehicle->track_type = (tileElement->properties.track.type << 2) | (direction & 3);
|
||||
vehicle->var_CF = tile_element_get_brake_booster_speed(tileElement);
|
||||
regs.ax = 0;
|
||||
|
||||
loc_6DC743:
|
||||
|
@ -9068,12 +9068,12 @@ loc_6DCA9A:
|
|||
_vehicleVAngleEndF64E36 = TrackDefinitions[trackType].vangle_end;
|
||||
_vehicleBankEndF64E37 = TrackDefinitions[trackType].bank_end;
|
||||
|
||||
mapElement =
|
||||
tileElement =
|
||||
map_get_track_element_at_of_type_seq(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3, trackType, 0);
|
||||
}
|
||||
{
|
||||
track_begin_end trackBeginEnd;
|
||||
if (!track_block_get_previous(vehicle->track_x, vehicle->track_y, mapElement, &trackBeginEnd))
|
||||
if (!track_block_get_previous(vehicle->track_x, vehicle->track_y, tileElement, &trackBeginEnd))
|
||||
{
|
||||
goto loc_6DC9BC;
|
||||
}
|
||||
|
@ -9081,20 +9081,20 @@ loc_6DCA9A:
|
|||
y = trackBeginEnd.begin_y;
|
||||
z = trackBeginEnd.begin_z;
|
||||
direction = trackBeginEnd.begin_direction;
|
||||
mapElement = trackBeginEnd.begin_element;
|
||||
tileElement = trackBeginEnd.begin_element;
|
||||
}
|
||||
|
||||
if (!loc_6DB38B(vehicle, mapElement))
|
||||
if (!loc_6DB38B(vehicle, tileElement))
|
||||
{
|
||||
goto loc_6DCD4A;
|
||||
}
|
||||
|
||||
{
|
||||
sint32 rideType = get_ride(mapElement->properties.track.ride_index)->type;
|
||||
sint32 rideType = get_ride(tileElement->properties.track.ride_index)->type;
|
||||
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
|
||||
if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_HAS_ALTERNATIVE_TRACK_TYPE)
|
||||
{
|
||||
if (track_element_is_inverted(mapElement))
|
||||
if (track_element_is_inverted(tileElement))
|
||||
{
|
||||
vehicle->update_flags |= VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
|
||||
}
|
||||
|
@ -9117,8 +9117,8 @@ loc_6DCA9A:
|
|||
}
|
||||
}
|
||||
|
||||
vehicle->track_type = (mapElement->properties.track.type << 2) | (direction & 3);
|
||||
vehicle->var_CF = (mapElement->properties.track.colour >> 4) << 1;
|
||||
vehicle->track_type = (tileElement->properties.track.type << 2) | (direction & 3);
|
||||
vehicle->var_CF = (tileElement->properties.track.colour >> 4) << 1;
|
||||
|
||||
// There are two bytes before the move info list
|
||||
regs.ax = vehicle_get_move_info_size(vehicle->var_CD, vehicle->track_type);
|
||||
|
|
|
@ -182,7 +182,7 @@ static uint32 air_powered_vertical_rc_get_support_colour(paint_session * session
|
|||
|
||||
/** rct2: 0x008AFAD4 */
|
||||
static void air_powered_vertical_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4] = {
|
||||
SPR_AIR_POWERED_VERTICAL_RC_FLAT_SW_NE,
|
||||
|
@ -203,7 +203,7 @@ static void air_powered_vertical_rc_track_flat(paint_session * session, uint8 ri
|
|||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_AIR_POWERED_VERTICAL_RC_STATION_SW_NE, SPR_STATION_BASE_B_SW_NE },
|
||||
|
@ -220,7 +220,7 @@ static void air_powered_vertical_rc_track_station(paint_session * session, uint8
|
|||
wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
|
||||
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
track_paint_util_draw_station_platform(session, ride, direction, height, 5, mapElement);
|
||||
track_paint_util_draw_station_platform(session, ride, direction, height, 5, tileElement);
|
||||
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
|
||||
|
@ -229,7 +229,7 @@ static void air_powered_vertical_rc_track_station(paint_session * session, uint8
|
|||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const sprite_bb imageIds[4][5] = {
|
||||
{
|
||||
|
@ -308,16 +308,16 @@ static void air_powered_vertical_rc_track_right_quarter_turn_5(paint_session * s
|
|||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
air_powered_vertical_rc_track_right_quarter_turn_5(session, rideIndex, trackSequence, (direction + 1) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008AFB74 */
|
||||
static void air_powered_vertical_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_AIR_POWERED_VERTICAL_RC_FLAT_TO_LEFT_BANK_SW_NE, SPR_AIR_POWERED_VERTICAL_RC_FLAT_TO_LEFT_BANK_FRONT_SW_NE },
|
||||
|
@ -345,7 +345,7 @@ static void air_powered_vertical_rc_track_flat_to_left_bank(paint_session * sess
|
|||
|
||||
/** rct2: 0x008AFB84 */
|
||||
static void air_powered_vertical_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_AIR_POWERED_VERTICAL_RC_FLAT_TO_RIGHT_BANK_SW_NE, SPR_AIR_POWERED_VERTICAL_RC_FLAT_TO_LEFT_BANK_FRONT_SW_NE },
|
||||
|
@ -372,22 +372,22 @@ static void air_powered_vertical_rc_track_flat_to_right_bank(paint_session * ses
|
|||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
air_powered_vertical_rc_track_flat_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008AFBA4 */
|
||||
static void air_powered_vertical_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
air_powered_vertical_rc_track_flat_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
air_powered_vertical_rc_track_flat_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
static const sprite_bb imageIds[4][5] = {
|
||||
{
|
||||
|
@ -481,16 +481,16 @@ static void air_powered_vertical_rc_track_banked_right_quarter_turn_5(paint_sess
|
|||
|
||||
static void air_powered_vertical_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
air_powered_vertical_rc_track_banked_right_quarter_turn_5(session, rideIndex, trackSequence, (direction + 1) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008AFBD4 */
|
||||
static void air_powered_vertical_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4] = {
|
||||
SPR_AIR_POWERED_VERTICAL_RC_LEFT_BANK_SW_NE,
|
||||
|
@ -518,13 +518,13 @@ static void air_powered_vertical_rc_track_left_bank(paint_session * session, uin
|
|||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
air_powered_vertical_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
air_powered_vertical_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4] = {
|
||||
SPR_AIR_POWERED_VERTICAL_RC_BRAKES_NW_SE,
|
||||
|
@ -545,7 +545,7 @@ static void air_powered_vertical_rc_track_brakes(paint_session * session, uint8
|
|||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_vertical_slope_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 trackImageIds[7][4] = {
|
||||
{
|
||||
|
@ -747,7 +747,7 @@ static void air_powered_vertical_rc_track_vertical_slope_up(paint_session * sess
|
|||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_vertical_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_AIR_POWERED_VERTICAL_RC_VERTICAL_UP_SW_NE_SEQ_0, SPR_AIR_POWERED_VERTICAL_RC_VERTICAL_UP_SW_NE_SEQ_1 },
|
||||
|
@ -783,12 +783,12 @@ static void air_powered_vertical_rc_track_vertical_up(paint_session * session, u
|
|||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_vertical_top(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (direction == 2 || direction == 3)
|
||||
{
|
||||
air_powered_vertical_rc_track_vertical_top(session, rideIndex, 3 - trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -865,16 +865,16 @@ static void air_powered_vertical_rc_track_vertical_top(paint_session * session,
|
|||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_vertical_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
air_powered_vertical_rc_track_vertical_up(session, rideIndex, trackSequence ^ 1, (direction + 2) & 3, height, mapElement);
|
||||
air_powered_vertical_rc_track_vertical_up(session, rideIndex, trackSequence ^ 1, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
static void air_powered_vertical_rc_track_vertical_slope_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
air_powered_vertical_rc_track_vertical_slope_up(session, rideIndex, 6 - trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
TRACK_PAINT_FUNCTION get_track_paint_function_air_powered_vertical_rc(sint32 trackType, sint32 direction)
|
||||
|
|
|
@ -28,9 +28,9 @@
|
|||
|
||||
/** rct2: 0x006FE5B4 */
|
||||
static void bobsleigh_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -85,7 +85,7 @@ static void bobsleigh_rc_track_flat(paint_session * session, uint8 rideIndex, ui
|
|||
}
|
||||
|
||||
static void bobsleigh_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ 14580, SPR_STATION_BASE_B_SW_NE },
|
||||
|
@ -99,7 +99,7 @@ static void bobsleigh_rc_track_station(paint_session * session, uint8 rideIndex,
|
|||
sub_98196C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
|
||||
height);
|
||||
track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -107,9 +107,9 @@ static void bobsleigh_rc_track_station(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x006FE5C4 */
|
||||
static void bobsleigh_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -192,9 +192,9 @@ static void bobsleigh_rc_track_25_deg_up(paint_session * session, uint8 rideInde
|
|||
|
||||
/** rct2: 0x006FE5D4 */
|
||||
static void bobsleigh_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -277,9 +277,9 @@ static void bobsleigh_rc_track_flat_to_25_deg_up(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x006FE5E4 */
|
||||
static void bobsleigh_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -362,28 +362,28 @@ static void bobsleigh_rc_track_25_deg_up_to_flat(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x006FE5F4 */
|
||||
static void bobsleigh_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
bobsleigh_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE604 */
|
||||
static void bobsleigh_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
bobsleigh_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE614 */
|
||||
static void bobsleigh_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
bobsleigh_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE624 */
|
||||
static void bobsleigh_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -577,15 +577,15 @@ static void bobsleigh_rc_track_left_quarter_turn_5(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x006FE634 */
|
||||
static void bobsleigh_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
bobsleigh_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE644 */
|
||||
static void bobsleigh_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -626,7 +626,7 @@ static void bobsleigh_rc_track_flat_to_left_bank(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x006FE654 */
|
||||
static void bobsleigh_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -667,7 +667,7 @@ static void bobsleigh_rc_track_flat_to_right_bank(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x006FE664 */
|
||||
static void bobsleigh_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -708,7 +708,7 @@ static void bobsleigh_rc_track_left_bank_to_flat(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x006FE674 */
|
||||
static void bobsleigh_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -749,7 +749,7 @@ static void bobsleigh_rc_track_right_bank_to_flat(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x006FE684 */
|
||||
static void bobsleigh_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -943,15 +943,15 @@ static void bobsleigh_rc_track_banked_left_quarter_turn_5(paint_session * sessio
|
|||
|
||||
/** rct2: 0x006FE694 */
|
||||
static void bobsleigh_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
bobsleigh_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE6A4 */
|
||||
static void bobsleigh_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -999,7 +999,7 @@ static void bobsleigh_rc_track_left_bank_to_25_deg_up(paint_session * session, u
|
|||
|
||||
/** rct2: 0x006FE6B4 */
|
||||
static void bobsleigh_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1047,7 +1047,7 @@ static void bobsleigh_rc_track_right_bank_to_25_deg_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x006FE6C4 */
|
||||
static void bobsleigh_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1095,7 +1095,7 @@ static void bobsleigh_rc_track_25_deg_up_to_left_bank(paint_session * session, u
|
|||
|
||||
/** rct2: 0x006FE6D4 */
|
||||
static void bobsleigh_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1143,35 +1143,35 @@ static void bobsleigh_rc_track_25_deg_up_to_right_bank(paint_session * session,
|
|||
|
||||
/** rct2: 0x006FE6E4 */
|
||||
static void bobsleigh_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
bobsleigh_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE6F4 */
|
||||
static void bobsleigh_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
bobsleigh_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE704 */
|
||||
static void bobsleigh_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
bobsleigh_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE714 */
|
||||
static void bobsleigh_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
bobsleigh_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE724 */
|
||||
static void bobsleigh_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1212,14 +1212,14 @@ static void bobsleigh_rc_track_left_bank(paint_session * session, uint8 rideInde
|
|||
|
||||
/** rct2: 0x006FE734 */
|
||||
static void bobsleigh_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
bobsleigh_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE744 */
|
||||
static void bobsleigh_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1379,7 +1379,7 @@ static void bobsleigh_rc_track_s_bend_left(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x006FE754 */
|
||||
static void bobsleigh_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1539,7 +1539,7 @@ static void bobsleigh_rc_track_s_bend_right(paint_session * session, uint8 rideI
|
|||
|
||||
/** rct2: 0x006FE794 */
|
||||
static void bobsleigh_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1662,15 +1662,15 @@ static void bobsleigh_rc_track_left_quarter_turn_3(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x006FE7A4 */
|
||||
static void bobsleigh_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
bobsleigh_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE7B4 */
|
||||
static void bobsleigh_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1793,15 +1793,15 @@ static void bobsleigh_rc_track_left_quarter_turn_3_bank(paint_session * session,
|
|||
|
||||
/** rct2: 0x006FE7C4 */
|
||||
static void bobsleigh_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
bobsleigh_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
bobsleigh_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE7D4 */
|
||||
static void bobsleigh_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2042,7 +2042,7 @@ static void bobsleigh_rc_track_left_half_banked_helix_up_small(paint_session * s
|
|||
|
||||
/** rct2: 0x006FE7E4 */
|
||||
static void bobsleigh_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2283,7 +2283,7 @@ static void bobsleigh_rc_track_right_half_banked_helix_up_small(paint_session *
|
|||
|
||||
/** rct2: 0x006FE7F4 */
|
||||
static void bobsleigh_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (trackSequence >= 4)
|
||||
{
|
||||
|
@ -2292,12 +2292,12 @@ static void bobsleigh_rc_track_left_half_banked_helix_down_small(paint_session *
|
|||
}
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
bobsleigh_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE804 */
|
||||
static void bobsleigh_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (trackSequence >= 4)
|
||||
{
|
||||
|
@ -2306,12 +2306,12 @@ static void bobsleigh_rc_track_right_half_banked_helix_down_small(paint_session
|
|||
}
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
bobsleigh_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE814 */
|
||||
static void bobsleigh_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2694,7 +2694,7 @@ static void bobsleigh_rc_track_left_half_banked_helix_up_large(paint_session * s
|
|||
|
||||
/** rct2: 0x006FE824 */
|
||||
static void bobsleigh_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3077,7 +3077,7 @@ static void bobsleigh_rc_track_right_half_banked_helix_up_large(paint_session *
|
|||
|
||||
/** rct2: 0x006FE834 */
|
||||
static void bobsleigh_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (trackSequence >= 7)
|
||||
{
|
||||
|
@ -3086,12 +3086,12 @@ static void bobsleigh_rc_track_left_half_banked_helix_down_large(paint_session *
|
|||
}
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
bobsleigh_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE844 */
|
||||
static void bobsleigh_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (trackSequence >= 7)
|
||||
{
|
||||
|
@ -3100,12 +3100,12 @@ static void bobsleigh_rc_track_right_half_banked_helix_down_large(paint_session
|
|||
}
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
bobsleigh_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006FE854 */
|
||||
static void bobsleigh_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3136,7 +3136,7 @@ static void bobsleigh_rc_track_brakes(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x006FE864 */
|
||||
static void bobsleigh_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3166,7 +3166,7 @@ static void bobsleigh_rc_track_block_brakes(paint_session * session, uint8 rideI
|
|||
}
|
||||
|
||||
static void bobsleigh_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3209,7 +3209,7 @@ static void bobsleigh_rc_track_on_ride_photo(paint_session * session, uint8 ride
|
|||
|
||||
break;
|
||||
}
|
||||
track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
|
||||
track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -14,187 +14,187 @@
|
|||
*****************************************************************************/
|
||||
#pragma endregion
|
||||
|
||||
void bolliger_mabillard_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_bank_to_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_bank_to_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_3_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_3_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_bank_to_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_bank_to_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_3_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_3_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
|
||||
/* Previously specific to the Vertical RC */
|
||||
void bolliger_mabillard_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_brake_for_drop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_brake_for_drop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
|
||||
/* Previously specific to the Steel Twister */
|
||||
void bolliger_mabillard_track_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_60_deg_up_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up_to_flat_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_60_deg_down_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up_to_flat_long_base122(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_powered_lift(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_90_deg_to_inverted_flat_quarter_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_inverted_flat_to_90_deg_quarter_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_60_deg_up_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up_to_flat_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_flat_to_60_deg_down_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_60_deg_up_to_flat_long_base122(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_powered_lift(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_right_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_left_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_90_deg_to_inverted_flat_quarter_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_inverted_flat_to_90_deg_quarter_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
|
||||
void bolliger_mabillard_track_booster(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
|
||||
void bolliger_mabillard_track_booster(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
|
||||
|
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -28,9 +28,9 @@
|
|||
|
||||
/** rct2: 0x0087694C */
|
||||
static void heartline_twister_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -92,7 +92,7 @@ static void heartline_twister_rc_track_flat(paint_session * session, uint8 rideI
|
|||
}
|
||||
|
||||
static void heartline_twister_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][3] = {
|
||||
{ 19732, SPR_STATION_BASE_B_SW_NE },
|
||||
|
@ -106,7 +106,7 @@ static void heartline_twister_rc_track_station(paint_session * session, uint8 ri
|
|||
sub_98196C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
|
||||
height);
|
||||
track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -114,9 +114,9 @@ static void heartline_twister_rc_track_station(paint_session * session, uint8 ri
|
|||
|
||||
/** rct2: 0x0087695C */
|
||||
static void heartline_twister_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -198,9 +198,9 @@ static void heartline_twister_rc_track_25_deg_up(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x008769FC */
|
||||
static void heartline_twister_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -282,9 +282,9 @@ static void heartline_twister_rc_track_60_deg_up(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x0087696C */
|
||||
static void heartline_twister_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -366,9 +366,9 @@ static void heartline_twister_rc_track_flat_to_25_deg_up(paint_session * session
|
|||
|
||||
/** rct2: 0x008769BC */
|
||||
static void heartline_twister_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -450,9 +450,9 @@ static void heartline_twister_rc_track_25_deg_up_to_60_deg_up(paint_session * se
|
|||
|
||||
/** rct2: 0x008769CC */
|
||||
static void heartline_twister_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -534,9 +534,9 @@ static void heartline_twister_rc_track_60_deg_up_to_25_deg_up(paint_session * se
|
|||
|
||||
/** rct2: 0x0087697C */
|
||||
static void heartline_twister_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -618,51 +618,51 @@ static void heartline_twister_rc_track_25_deg_up_to_flat(paint_session * session
|
|||
|
||||
/** rct2: 0x0087698C */
|
||||
static void heartline_twister_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
heartline_twister_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
heartline_twister_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00876A0C */
|
||||
static void heartline_twister_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
heartline_twister_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
heartline_twister_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0087699C */
|
||||
static void heartline_twister_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
heartline_twister_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
heartline_twister_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008769DC */
|
||||
static void heartline_twister_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
heartline_twister_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008769EC */
|
||||
static void heartline_twister_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
heartline_twister_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008769AC */
|
||||
static void heartline_twister_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
heartline_twister_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
heartline_twister_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00876A6C */
|
||||
static void heartline_twister_rc_track_heartline_transfer_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -839,7 +839,7 @@ static void heartline_twister_rc_track_heartline_transfer_up(paint_session * ses
|
|||
|
||||
/** rct2: 0x00876A7C */
|
||||
static void heartline_twister_rc_track_heartline_transfer_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1016,7 +1016,7 @@ static void heartline_twister_rc_track_heartline_transfer_down(paint_session * s
|
|||
|
||||
/** rct2: 0x00876A4C */
|
||||
static void heartline_twister_rc_track_left_heartline_roll(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1237,7 +1237,7 @@ static void heartline_twister_rc_track_left_heartline_roll(paint_session * sessi
|
|||
|
||||
/** rct2: 0x00876A5C */
|
||||
static void heartline_twister_rc_track_right_heartline_roll(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
|
|
@ -28,9 +28,9 @@
|
|||
|
||||
/** rct2: 0x00890CB4 */
|
||||
static void inverted_hairpin_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -83,7 +83,7 @@ static void inverted_hairpin_rc_track_flat(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x00890D84, 0x00890D94, 0x00890DA4 */
|
||||
static void inverted_hairpin_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][3] = {
|
||||
{ SPR_STATION_BASE_C_SW_NE, 17028, SPR_STATION_INVERTED_BAR_0_SW_NE },
|
||||
|
@ -99,7 +99,7 @@ static void inverted_hairpin_rc_track_station(paint_session * session, uint8 rid
|
|||
sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 1,
|
||||
height + 24, 0, 6, height + 24);
|
||||
track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 11);
|
||||
track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement, STATION_VARIANT_1);
|
||||
track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement, STATION_VARIANT_1);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -107,9 +107,9 @@ static void inverted_hairpin_rc_track_station(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x00890CC4 */
|
||||
static void inverted_hairpin_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -192,9 +192,9 @@ static void inverted_hairpin_rc_track_25_deg_up(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x00890CD4 */
|
||||
static void inverted_hairpin_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -253,9 +253,9 @@ static void inverted_hairpin_rc_track_60_deg_up(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x00890CE4 */
|
||||
static void inverted_hairpin_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -338,9 +338,9 @@ static void inverted_hairpin_rc_track_flat_to_25_deg_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x00890CF4 */
|
||||
static void inverted_hairpin_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -407,9 +407,9 @@ static void inverted_hairpin_rc_track_25_deg_up_to_60_deg_up(paint_session * ses
|
|||
|
||||
/** rct2: 0x00890D04 */
|
||||
static void inverted_hairpin_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -500,9 +500,9 @@ static void inverted_hairpin_rc_track_60_deg_up_to_25_deg_up(paint_session * ses
|
|||
|
||||
/** rct2: 0x00890D14 */
|
||||
static void inverted_hairpin_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -585,51 +585,51 @@ static void inverted_hairpin_rc_track_25_deg_up_to_flat(paint_session * session,
|
|||
|
||||
/** rct2: 0x00890D24 */
|
||||
static void inverted_hairpin_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_hairpin_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
inverted_hairpin_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890D34 */
|
||||
static void inverted_hairpin_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_hairpin_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
inverted_hairpin_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890D44 */
|
||||
static void inverted_hairpin_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_hairpin_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
inverted_hairpin_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890D54 */
|
||||
static void inverted_hairpin_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_hairpin_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890D64 */
|
||||
static void inverted_hairpin_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_hairpin_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890D74 */
|
||||
static void inverted_hairpin_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_hairpin_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
inverted_hairpin_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890DB4 */
|
||||
static void inverted_hairpin_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -736,16 +736,16 @@ static void inverted_hairpin_rc_track_left_quarter_turn_3(paint_session * sessio
|
|||
|
||||
/** rct2: 0x00890DC4 */
|
||||
static void inverted_hairpin_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
inverted_hairpin_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
inverted_hairpin_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890DD4 */
|
||||
static void inverted_hairpin_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -824,7 +824,7 @@ static void inverted_hairpin_rc_track_left_quarter_turn_3_25_deg_up(paint_sessio
|
|||
/** rct2: 0x00890DE4 */
|
||||
static void inverted_hairpin_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -903,26 +903,26 @@ static void inverted_hairpin_rc_track_right_quarter_turn_3_25_deg_up(paint_sessi
|
|||
/** rct2: 0x00890DF4 */
|
||||
static void inverted_hairpin_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
inverted_hairpin_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890E04 */
|
||||
static void inverted_hairpin_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
inverted_hairpin_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890E64 */
|
||||
static void inverted_hairpin_rc_track_left_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -967,16 +967,16 @@ static void inverted_hairpin_rc_track_left_quarter_turn_1(paint_session * sessio
|
|||
|
||||
/** rct2: 0x00890E74 */
|
||||
static void inverted_hairpin_rc_track_right_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_hairpin_rc_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
inverted_hairpin_rc_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890E24 */
|
||||
static void inverted_hairpin_rc_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1043,9 +1043,9 @@ static void inverted_hairpin_rc_track_flat_to_60_deg_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x00890E34 */
|
||||
static void inverted_hairpin_rc_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1133,21 +1133,21 @@ static void inverted_hairpin_rc_track_60_deg_up_to_flat(paint_session * session,
|
|||
|
||||
/** rct2: 0x00890E44 */
|
||||
static void inverted_hairpin_rc_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_hairpin_rc_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
inverted_hairpin_rc_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890E54 */
|
||||
static void inverted_hairpin_rc_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_hairpin_rc_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
inverted_hairpin_rc_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00890E14 */
|
||||
static void inverted_hairpin_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1177,7 +1177,7 @@ static void inverted_hairpin_rc_track_brakes(paint_session * session, uint8 ride
|
|||
|
||||
/** rct2: 0x00890E84 */
|
||||
static void inverted_hairpin_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
|
|
@ -28,7 +28,7 @@
|
|||
|
||||
/** rct2: 0x008B0460 */
|
||||
static void inverted_impulse_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -58,7 +58,7 @@ static void inverted_impulse_rc_track_flat(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x008B0470, 0x008B0480, 0x008B0490 */
|
||||
static void inverted_impulse_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][3] = {
|
||||
{ SPR_STATION_BASE_C_SW_NE, 19662, SPR_STATION_INVERTED_BAR_B_SW_NE },
|
||||
|
@ -74,7 +74,7 @@ static void inverted_impulse_rc_track_station(paint_session * session, uint8 rid
|
|||
sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 3,
|
||||
height + 29, 0, 6, height + 29);
|
||||
track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 11);
|
||||
track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement,
|
||||
track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement,
|
||||
STATION_VARIANT_TALL);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_9);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
|
@ -83,7 +83,7 @@ static void inverted_impulse_rc_track_station(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x008B04A0 */
|
||||
static void inverted_impulse_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -143,7 +143,7 @@ static void inverted_impulse_rc_track_25_deg_up(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x008B04B0 */
|
||||
static void inverted_impulse_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -179,7 +179,7 @@ static void inverted_impulse_rc_track_60_deg_up(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x008B04C0 */
|
||||
static void inverted_impulse_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -236,7 +236,7 @@ static void inverted_impulse_rc_track_flat_to_25_deg_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x008B04D0 */
|
||||
static void inverted_impulse_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -276,7 +276,7 @@ static void inverted_impulse_rc_track_25_deg_up_to_60_deg_up(paint_session * ses
|
|||
|
||||
/** rct2: 0x008B04E0 */
|
||||
static void inverted_impulse_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -316,7 +316,7 @@ static void inverted_impulse_rc_track_60_deg_up_to_25_deg_up(paint_session * ses
|
|||
|
||||
/** rct2: 0x008B04F0 */
|
||||
static void inverted_impulse_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -373,51 +373,51 @@ static void inverted_impulse_rc_track_25_deg_up_to_flat(paint_session * session,
|
|||
|
||||
/** rct2: 0x008B0500 */
|
||||
static void inverted_impulse_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_impulse_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
inverted_impulse_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0510 */
|
||||
static void inverted_impulse_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_impulse_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
inverted_impulse_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0520 */
|
||||
static void inverted_impulse_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_impulse_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
inverted_impulse_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0530 */
|
||||
static void inverted_impulse_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_impulse_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0540 */
|
||||
static void inverted_impulse_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_impulse_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0550 */
|
||||
static void inverted_impulse_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_impulse_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
inverted_impulse_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B05A0 */
|
||||
static void inverted_impulse_rc_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -453,14 +453,14 @@ static void inverted_impulse_rc_track_90_deg_up(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x008B05B0 */
|
||||
static void inverted_impulse_rc_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_impulse_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
inverted_impulse_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0560 */
|
||||
static void inverted_impulse_rc_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -500,15 +500,15 @@ static void inverted_impulse_rc_track_60_deg_up_to_90_deg_up(paint_session * ses
|
|||
|
||||
/** rct2: 0x008B0570 */
|
||||
static void inverted_impulse_rc_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_impulse_rc_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0580 */
|
||||
static void inverted_impulse_rc_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -545,7 +545,7 @@ static void inverted_impulse_rc_track_90_deg_up_to_60_deg_up(paint_session * ses
|
|||
|
||||
/** rct2: 0x008B0590 */
|
||||
static void inverted_impulse_rc_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -585,7 +585,7 @@ static void inverted_impulse_rc_track_60_deg_down_to_90_deg_down(paint_session *
|
|||
/** rct2: 0x008B05C0 */
|
||||
static void inverted_impulse_rc_track_left_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -628,7 +628,7 @@ static void inverted_impulse_rc_track_left_quarter_turn_1_90_deg_up(paint_sessio
|
|||
/** rct2: 0x008B05D0 */
|
||||
static void inverted_impulse_rc_track_right_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -671,19 +671,19 @@ static void inverted_impulse_rc_track_right_quarter_turn_1_90_deg_up(paint_sessi
|
|||
/** rct2: 0x008B05E0 */
|
||||
static void inverted_impulse_rc_track_left_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_impulse_rc_track_right_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B05F0 */
|
||||
static void inverted_impulse_rc_track_right_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
inverted_impulse_rc_track_left_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
TRACK_PAINT_FUNCTION get_track_paint_function_inverted_impulse_rc(sint32 trackType, sint32 direction)
|
||||
|
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -27,38 +27,38 @@ typedef enum JUNIOR_RC_CHAINTYPE
|
|||
JUNIOR_RC_CHAIN_CHAIN_LIFT,
|
||||
} JUNIOR_RC_CHAINTYPE;
|
||||
|
||||
void junior_rc_paint_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, uint8 rideType);
|
||||
void junior_rc_paint_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, uint8 rideType);
|
||||
|
||||
void junior_rc_paint_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
|
||||
void junior_rc_paint_track_left_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_right_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_left_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_right_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
|
||||
void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
|
||||
void junior_rc_paint_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
void junior_rc_paint_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
|
||||
|
||||
#endif // _JUNIOR_ROLLER_COASTER_H
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -28,7 +28,7 @@
|
|||
|
||||
/** rct2: 0x008A6D50, 0x008A6D60, 0x008A6D70 */
|
||||
static void lim_launched_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][3] = {
|
||||
{ 15018, 15020, SPR_STATION_BASE_B_SW_NE },
|
||||
|
@ -37,7 +37,7 @@ static void lim_launched_rc_track_station(paint_session * session, uint8 rideInd
|
|||
{ 15019, 15021, SPR_STATION_BASE_B_NW_SE },
|
||||
};
|
||||
|
||||
if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
|
||||
if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
|
||||
{
|
||||
sub_98197C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 20, 1,
|
||||
height, 0, 6, height + 3);
|
||||
|
@ -50,7 +50,7 @@ static void lim_launched_rc_track_station(paint_session * session, uint8 rideInd
|
|||
sub_98196C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
|
||||
height);
|
||||
track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -58,7 +58,7 @@ static void lim_launched_rc_track_station(paint_session * session, uint8 rideInd
|
|||
|
||||
/** rct2: 0x008A65E0 */
|
||||
static void lim_launched_rc_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -274,7 +274,7 @@ static void lim_launched_rc_track_left_vertical_loop(paint_session * session, ui
|
|||
|
||||
/** rct2: 0x008A65F0 */
|
||||
static void lim_launched_rc_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -458,7 +458,7 @@ static void lim_launched_rc_track_right_vertical_loop(paint_session * session, u
|
|||
|
||||
/** rct2: 0x008A6D10 */
|
||||
static void lim_launched_rc_track_left_twist_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -581,7 +581,7 @@ static void lim_launched_rc_track_left_twist_down_to_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x008A6D20 */
|
||||
static void lim_launched_rc_track_right_twist_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -704,7 +704,7 @@ static void lim_launched_rc_track_right_twist_down_to_up(paint_session * session
|
|||
|
||||
/** rct2: 0x008A6D30 */
|
||||
static void lim_launched_rc_track_left_twist_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -827,7 +827,7 @@ static void lim_launched_rc_track_left_twist_up_to_down(paint_session * session,
|
|||
|
||||
/** rct2: 0x008A6D40 */
|
||||
static void lim_launched_rc_track_right_twist_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -950,7 +950,7 @@ static void lim_launched_rc_track_right_twist_up_to_down(paint_session * session
|
|||
|
||||
/** rct2: 0x008A6CD0 */
|
||||
static void lim_launched_rc_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1048,7 +1048,7 @@ static void lim_launched_rc_track_left_corkscrew_up(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x008A6CE0 */
|
||||
static void lim_launched_rc_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1147,21 +1147,21 @@ static void lim_launched_rc_track_right_corkscrew_up(paint_session * session, ui
|
|||
|
||||
/** rct2: 0x008A6CF0 */
|
||||
static void lim_launched_rc_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
lim_launched_rc_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, mapElement);
|
||||
lim_launched_rc_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A6D00 */
|
||||
static void lim_launched_rc_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
lim_launched_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
lim_launched_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A6D80 */
|
||||
static void lim_launched_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1188,7 +1188,7 @@ static void lim_launched_rc_track_brakes(paint_session * session, uint8 rideInde
|
|||
|
||||
/** rct2: 0x008A6C10 */
|
||||
static void lim_launched_rc_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1224,14 +1224,14 @@ static void lim_launched_rc_track_90_deg_up(paint_session * session, uint8 rideI
|
|||
|
||||
/** rct2: 0x008A6C20 */
|
||||
static void lim_launched_rc_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
lim_launched_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
lim_launched_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A6C30 */
|
||||
static void lim_launched_rc_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1271,14 +1271,14 @@ static void lim_launched_rc_track_60_deg_up_to_90_deg_up(paint_session * session
|
|||
|
||||
/** rct2: 0x008A6C40 */
|
||||
static void lim_launched_rc_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
lim_launched_rc_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
lim_launched_rc_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A6C50 */
|
||||
static void lim_launched_rc_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1315,7 +1315,7 @@ static void lim_launched_rc_track_90_deg_up_to_60_deg_up(paint_session * session
|
|||
|
||||
/** rct2: 0x008A6C60 */
|
||||
static void lim_launched_rc_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1355,7 +1355,7 @@ static void lim_launched_rc_track_60_deg_down_to_90_deg_down(paint_session * ses
|
|||
/** rct2: 0x008A6C70 */
|
||||
static void lim_launched_rc_track_90_deg_to_inverted_flat_quarter_loop_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1441,15 +1441,15 @@ static void lim_launched_rc_track_90_deg_to_inverted_flat_quarter_loop_up(paint_
|
|||
/** rct2: 0x008A6C80 */
|
||||
static void lim_launched_rc_track_inverted_flat_to_90_deg_quarter_loop_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
lim_launched_rc_track_90_deg_to_inverted_flat_quarter_loop_up(session, rideIndex, 2 - trackSequence, direction, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A6D90 */
|
||||
static void lim_launched_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1475,7 +1475,7 @@ static void lim_launched_rc_track_block_brakes(paint_session * session, uint8 ri
|
|||
}
|
||||
|
||||
static void lim_launched_rc_track_left_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1515,7 +1515,7 @@ static void lim_launched_rc_track_left_quarter_turn_1_90_deg_up(paint_session *
|
|||
|
||||
/** rct2: 0x008A6CA0 */
|
||||
static void lim_launched_rc_track_right_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1555,19 +1555,19 @@ static void lim_launched_rc_track_right_quarter_turn_1_90_deg_up(paint_session *
|
|||
|
||||
/** rct2: 0x008A6CB0 */
|
||||
static void lim_launched_rc_track_left_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
lim_launched_rc_track_right_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A6CC0 */
|
||||
static void lim_launched_rc_track_right_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
lim_launched_rc_track_left_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
TRACK_PAINT_FUNCTION get_track_paint_function_lim_launched_rc(sint32 trackType, sint32 direction)
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -28,7 +28,7 @@
|
|||
|
||||
/** rct2: 0x008B08D0 */
|
||||
static void mine_ride_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -59,7 +59,7 @@ static void mine_ride_track_flat(paint_session * session, uint8 rideIndex, uint8
|
|||
}
|
||||
|
||||
static void mine_ride_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][3] = {
|
||||
{ 19338, SPR_STATION_BASE_A_SW_NE },
|
||||
|
@ -73,7 +73,7 @@ static void mine_ride_track_station(paint_session * session, uint8 rideIndex, ui
|
|||
sub_98196C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
|
||||
height);
|
||||
track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
|
||||
track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
|
||||
track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -81,7 +81,7 @@ static void mine_ride_track_station(paint_session * session, uint8 rideIndex, ui
|
|||
|
||||
/** rct2: 0x008B08E0 */
|
||||
static void mine_ride_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -135,7 +135,7 @@ static void mine_ride_track_25_deg_up(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x008B08F0 */
|
||||
static void mine_ride_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -189,7 +189,7 @@ static void mine_ride_track_flat_to_25_deg_up(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x008B0900 */
|
||||
static void mine_ride_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -243,28 +243,28 @@ static void mine_ride_track_25_deg_up_to_flat(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x008B0910 */
|
||||
static void mine_ride_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
mine_ride_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mine_ride_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0920 */
|
||||
static void mine_ride_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
mine_ride_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mine_ride_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0930 */
|
||||
static void mine_ride_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
mine_ride_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mine_ride_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0940 */
|
||||
static void mine_ride_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -428,15 +428,15 @@ static void mine_ride_track_left_quarter_turn_5(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x008B0950 */
|
||||
static void mine_ride_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
mine_ride_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
mine_ride_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0960 */
|
||||
static void mine_ride_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -487,7 +487,7 @@ static void mine_ride_track_flat_to_left_bank(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x008B0970 */
|
||||
static void mine_ride_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -538,7 +538,7 @@ static void mine_ride_track_flat_to_right_bank(paint_session * session, uint8 ri
|
|||
|
||||
/** rct2: 0x008B0980 */
|
||||
static void mine_ride_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -589,7 +589,7 @@ static void mine_ride_track_left_bank_to_flat(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x008B0990 */
|
||||
static void mine_ride_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -640,7 +640,7 @@ static void mine_ride_track_right_bank_to_flat(paint_session * session, uint8 ri
|
|||
|
||||
/** rct2: 0x008B09A0 */
|
||||
static void mine_ride_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -808,15 +808,15 @@ static void mine_ride_track_banked_left_quarter_turn_5(paint_session * session,
|
|||
|
||||
/** rct2: 0x008B09B0 */
|
||||
static void mine_ride_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
mine_ride_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
mine_ride_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B09C0 */
|
||||
static void mine_ride_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -874,7 +874,7 @@ static void mine_ride_track_left_bank_to_25_deg_up(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x008B09D0 */
|
||||
static void mine_ride_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -932,7 +932,7 @@ static void mine_ride_track_right_bank_to_25_deg_up(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x008B09E0 */
|
||||
static void mine_ride_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -990,7 +990,7 @@ static void mine_ride_track_25_deg_up_to_left_bank(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x008B09F0 */
|
||||
static void mine_ride_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1048,35 +1048,35 @@ static void mine_ride_track_25_deg_up_to_right_bank(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x008B0A00 */
|
||||
static void mine_ride_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
mine_ride_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mine_ride_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0A10 */
|
||||
static void mine_ride_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
mine_ride_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mine_ride_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0A20 */
|
||||
static void mine_ride_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
mine_ride_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mine_ride_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0A30 */
|
||||
static void mine_ride_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
mine_ride_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mine_ride_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0A40 */
|
||||
static void mine_ride_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1123,14 +1123,14 @@ static void mine_ride_track_left_bank(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x008B0A50 */
|
||||
static void mine_ride_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
mine_ride_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mine_ride_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0A60 */
|
||||
static void mine_ride_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1266,7 +1266,7 @@ static void mine_ride_track_s_bend_left(paint_session * session, uint8 rideIndex
|
|||
|
||||
/** rct2: 0x008B0A70 */
|
||||
static void mine_ride_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1402,7 +1402,7 @@ static void mine_ride_track_s_bend_right(paint_session * session, uint8 rideInde
|
|||
|
||||
/** rct2: 0x008B0AB0 */
|
||||
static void mine_ride_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1511,15 +1511,15 @@ static void mine_ride_track_left_quarter_turn_3(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x008B0AC0 */
|
||||
static void mine_ride_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
mine_ride_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
mine_ride_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0AD0 */
|
||||
static void mine_ride_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1632,15 +1632,15 @@ static void mine_ride_track_left_quarter_turn_3_bank(paint_session * session, ui
|
|||
|
||||
/** rct2: 0x008B0AE0 */
|
||||
static void mine_ride_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
mine_ride_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
mine_ride_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0AF0 */
|
||||
static void mine_ride_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1861,7 +1861,7 @@ static void mine_ride_track_left_half_banked_helix_up_small(paint_session * sess
|
|||
|
||||
/** rct2: 0x008B0B00 */
|
||||
static void mine_ride_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2082,7 +2082,7 @@ static void mine_ride_track_right_half_banked_helix_up_small(paint_session * ses
|
|||
|
||||
/** rct2: 0x008B0B10 */
|
||||
static void mine_ride_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (trackSequence >= 4)
|
||||
{
|
||||
|
@ -2091,12 +2091,12 @@ static void mine_ride_track_left_half_banked_helix_down_small(paint_session * se
|
|||
}
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
mine_ride_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0B20 */
|
||||
static void mine_ride_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (trackSequence >= 4)
|
||||
{
|
||||
|
@ -2104,12 +2104,12 @@ static void mine_ride_track_right_half_banked_helix_down_small(paint_session * s
|
|||
direction = (direction + 1) & 3;
|
||||
}
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
mine_ride_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
mine_ride_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0B30 */
|
||||
static void mine_ride_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2440,7 +2440,7 @@ static void mine_ride_track_left_half_banked_helix_up_large(paint_session * sess
|
|||
|
||||
/** rct2: 0x008B0B40 */
|
||||
static void mine_ride_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2771,7 +2771,7 @@ static void mine_ride_track_right_half_banked_helix_up_large(paint_session * ses
|
|||
|
||||
/** rct2: 0x008B0B50 */
|
||||
static void mine_ride_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (trackSequence >= 7)
|
||||
{
|
||||
|
@ -2780,12 +2780,12 @@ static void mine_ride_track_left_half_banked_helix_down_large(paint_session * se
|
|||
}
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
mine_ride_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0B60 */
|
||||
static void mine_ride_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (trackSequence >= 7)
|
||||
{
|
||||
|
@ -2793,12 +2793,12 @@ static void mine_ride_track_right_half_banked_helix_down_large(paint_session * s
|
|||
direction = (direction + 1) & 3;
|
||||
}
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
mine_ride_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
mine_ride_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0B70 */
|
||||
static void mine_ride_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2831,7 +2831,7 @@ static void mine_ride_track_on_ride_photo(paint_session * session, uint8 rideInd
|
|||
height + 3);
|
||||
break;
|
||||
}
|
||||
track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
|
||||
track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
|
@ -2839,7 +2839,7 @@ static void mine_ride_track_on_ride_photo(paint_session * session, uint8 rideInd
|
|||
|
||||
/** rct2: 0x008B0B90 */
|
||||
static void mine_ride_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2970,7 +2970,7 @@ static void mine_ride_track_left_eighth_to_diag(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x008B0BA0 */
|
||||
static void mine_ride_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3101,23 +3101,23 @@ static void mine_ride_track_right_eighth_to_diag(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x008B0BB0 */
|
||||
static void mine_ride_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
mine_ride_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mine_ride_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0BC0 */
|
||||
static void mine_ride_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
mine_ride_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
|
||||
mine_ride_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0BD0 */
|
||||
static void mine_ride_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3248,7 +3248,7 @@ static void mine_ride_track_left_eighth_bank_to_diag(paint_session * session, ui
|
|||
|
||||
/** rct2: 0x008B0BE0 */
|
||||
static void mine_ride_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3379,23 +3379,23 @@ static void mine_ride_track_right_eighth_bank_to_diag(paint_session * session, u
|
|||
|
||||
/** rct2: 0x008B0BF0 */
|
||||
static void mine_ride_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
mine_ride_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mine_ride_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0C00 */
|
||||
static void mine_ride_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
mine_ride_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
|
||||
mine_ride_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008B0B80 */
|
||||
static void mine_ride_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3464,7 +3464,7 @@ static void mine_ride_track_diag_flat(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x008B0C30 */
|
||||
static void mine_ride_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3533,7 +3533,7 @@ static void mine_ride_track_diag_25_deg_up(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x008B0C10 */
|
||||
static void mine_ride_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3602,7 +3602,7 @@ static void mine_ride_track_diag_flat_to_25_deg_up(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x008B0C20 */
|
||||
static void mine_ride_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3671,7 +3671,7 @@ static void mine_ride_track_diag_25_deg_up_to_flat(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x008B0C60 */
|
||||
static void mine_ride_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3740,7 +3740,7 @@ static void mine_ride_track_diag_25_deg_down(paint_session * session, uint8 ride
|
|||
|
||||
/** rct2: 0x008B0C40 */
|
||||
static void mine_ride_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3807,7 +3807,7 @@ static void mine_ride_track_diag_flat_to_25_deg_down(paint_session * session, ui
|
|||
|
||||
/** rct2: 0x008B0C50 */
|
||||
static void mine_ride_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3876,7 +3876,7 @@ static void mine_ride_track_diag_25_deg_down_to_flat(paint_session * session, ui
|
|||
|
||||
/** rct2: 0x008B0C90 */
|
||||
static void mine_ride_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3947,7 +3947,7 @@ static void mine_ride_track_diag_flat_to_left_bank(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x008B0CA0 */
|
||||
static void mine_ride_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4018,7 +4018,7 @@ static void mine_ride_track_diag_flat_to_right_bank(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x008B0CB0 */
|
||||
static void mine_ride_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4089,7 +4089,7 @@ static void mine_ride_track_diag_left_bank_to_flat(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x008B0CC0 */
|
||||
static void mine_ride_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4160,7 +4160,7 @@ static void mine_ride_track_diag_right_bank_to_flat(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x008B0CF0 */
|
||||
static void mine_ride_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4231,7 +4231,7 @@ static void mine_ride_track_diag_left_bank_to_25_deg_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x008B0D00 */
|
||||
static void mine_ride_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4302,7 +4302,7 @@ static void mine_ride_track_diag_right_bank_to_25_deg_up(paint_session * session
|
|||
|
||||
/** rct2: 0x008B0CD0 */
|
||||
static void mine_ride_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4373,7 +4373,7 @@ static void mine_ride_track_diag_25_deg_up_to_left_bank(paint_session * session,
|
|||
|
||||
/** rct2: 0x008B0CE0 */
|
||||
static void mine_ride_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4444,7 +4444,7 @@ static void mine_ride_track_diag_25_deg_up_to_right_bank(paint_session * session
|
|||
|
||||
/** rct2: 0x008B0D10 */
|
||||
static void mine_ride_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4513,7 +4513,7 @@ static void mine_ride_track_diag_left_bank_to_25_deg_down(paint_session * sessio
|
|||
|
||||
/** rct2: 0x008B0D20 */
|
||||
static void mine_ride_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4582,7 +4582,7 @@ static void mine_ride_track_diag_right_bank_to_25_deg_down(paint_session * sessi
|
|||
|
||||
/** rct2: 0x008B0D30 */
|
||||
static void mine_ride_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4653,7 +4653,7 @@ static void mine_ride_track_diag_25_deg_down_to_left_bank(paint_session * sessio
|
|||
|
||||
/** rct2: 0x008B0D40 */
|
||||
static void mine_ride_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4724,7 +4724,7 @@ static void mine_ride_track_diag_25_deg_down_to_right_bank(paint_session * sessi
|
|||
|
||||
/** rct2: 0x008B0C70 */
|
||||
static void mine_ride_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -4793,7 +4793,7 @@ static void mine_ride_track_diag_left_bank(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x008B0C80 */
|
||||
static void mine_ride_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -28,9 +28,9 @@
|
|||
|
||||
/** rct2: 0x008AFE9C */
|
||||
static void mini_suspended_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -84,7 +84,7 @@ static void mini_suspended_rc_track_flat(paint_session * session, uint8 rideInde
|
|||
|
||||
/** rct2: 0x008AFF4C, 0x008AFF5C, 0x008AFF6C */
|
||||
static void mini_suspended_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][3] = {
|
||||
{ SPR_STATION_BASE_C_SW_NE, 28433, SPR_STATION_INVERTED_BAR_E_SW_NE },
|
||||
|
@ -100,7 +100,7 @@ static void mini_suspended_rc_track_station(paint_session * session, uint8 rideI
|
|||
sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 1,
|
||||
height + 24, 0, 2, height);
|
||||
track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 3);
|
||||
track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement, STATION_VARIANT_1);
|
||||
track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement, STATION_VARIANT_1);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -108,9 +108,9 @@ static void mini_suspended_rc_track_station(paint_session * session, uint8 rideI
|
|||
|
||||
/** rct2: 0x008AFEAC */
|
||||
static void mini_suspended_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -193,9 +193,9 @@ static void mini_suspended_rc_track_25_deg_up(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x008AFEBC */
|
||||
static void mini_suspended_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -278,9 +278,9 @@ static void mini_suspended_rc_track_flat_to_25_deg_up(paint_session * session, u
|
|||
|
||||
/** rct2: 0x008AFECC */
|
||||
static void mini_suspended_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -363,28 +363,28 @@ static void mini_suspended_rc_track_25_deg_up_to_flat(paint_session * session, u
|
|||
|
||||
/** rct2: 0x008AFEDC */
|
||||
static void mini_suspended_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
mini_suspended_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mini_suspended_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008AFEEC */
|
||||
static void mini_suspended_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
mini_suspended_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mini_suspended_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008AFEFC */
|
||||
static void mini_suspended_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
mini_suspended_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mini_suspended_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008AFF0C */
|
||||
static void mini_suspended_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -548,15 +548,15 @@ static void mini_suspended_rc_track_left_quarter_turn_5(paint_session * session,
|
|||
|
||||
/** rct2: 0x008AFF1C */
|
||||
static void mini_suspended_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
mini_suspended_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
mini_suspended_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008AFF2C */
|
||||
static void mini_suspended_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -718,7 +718,7 @@ static void mini_suspended_rc_track_s_bend_left(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x008AFF3C */
|
||||
static void mini_suspended_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -880,7 +880,7 @@ static void mini_suspended_rc_track_s_bend_right(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x008AFF7C */
|
||||
static void mini_suspended_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -997,15 +997,15 @@ static void mini_suspended_rc_track_left_quarter_turn_3(paint_session * session,
|
|||
|
||||
/** rct2: 0x008AFF8C */
|
||||
static void mini_suspended_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
mini_suspended_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
mini_suspended_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008AFFAC */
|
||||
static void mini_suspended_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1161,7 +1161,7 @@ static void mini_suspended_rc_track_left_eighth_to_diag(paint_session * session,
|
|||
|
||||
/** rct2: 0x008AFFBC */
|
||||
static void mini_suspended_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1317,28 +1317,28 @@ static void mini_suspended_rc_track_right_eighth_to_diag(paint_session * session
|
|||
|
||||
/** rct2: 0x008AFFCC */
|
||||
static void mini_suspended_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
mini_suspended_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
mini_suspended_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008AFFDC */
|
||||
static void mini_suspended_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
mini_suspended_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
|
||||
mini_suspended_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008AFF9C */
|
||||
static void mini_suspended_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1363,7 +1363,7 @@ static void mini_suspended_rc_track_diag_flat(paint_session * session, uint8 rid
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1388,7 +1388,7 @@ static void mini_suspended_rc_track_diag_flat(paint_session * session, uint8 rid
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1413,7 +1413,7 @@ static void mini_suspended_rc_track_diag_flat(paint_session * session, uint8 rid
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1463,12 +1463,12 @@ static void mini_suspended_rc_track_diag_flat(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x008B000C */
|
||||
static void mini_suspended_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1493,7 +1493,7 @@ static void mini_suspended_rc_track_diag_25_deg_up(paint_session * session, uint
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1518,7 +1518,7 @@ static void mini_suspended_rc_track_diag_25_deg_up(paint_session * session, uint
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1543,7 +1543,7 @@ static void mini_suspended_rc_track_diag_25_deg_up(paint_session * session, uint
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1593,12 +1593,12 @@ static void mini_suspended_rc_track_diag_25_deg_up(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x008AFFEC */
|
||||
static void mini_suspended_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1623,7 +1623,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_up(paint_session * sessi
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1648,7 +1648,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_up(paint_session * sessi
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1673,7 +1673,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_up(paint_session * sessi
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1723,12 +1723,12 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_up(paint_session * sessi
|
|||
|
||||
/** rct2: 0x008AFFFC */
|
||||
static void mini_suspended_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1753,7 +1753,7 @@ static void mini_suspended_rc_track_diag_25_deg_up_to_flat(paint_session * sessi
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1778,7 +1778,7 @@ static void mini_suspended_rc_track_diag_25_deg_up_to_flat(paint_session * sessi
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1803,7 +1803,7 @@ static void mini_suspended_rc_track_diag_25_deg_up_to_flat(paint_session * sessi
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1853,12 +1853,12 @@ static void mini_suspended_rc_track_diag_25_deg_up_to_flat(paint_session * sessi
|
|||
|
||||
/** rct2: 0x008B003C */
|
||||
static void mini_suspended_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1883,7 +1883,7 @@ static void mini_suspended_rc_track_diag_25_deg_down(paint_session * session, ui
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1908,7 +1908,7 @@ static void mini_suspended_rc_track_diag_25_deg_down(paint_session * session, ui
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1933,7 +1933,7 @@ static void mini_suspended_rc_track_diag_25_deg_down(paint_session * session, ui
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1983,12 +1983,12 @@ static void mini_suspended_rc_track_diag_25_deg_down(paint_session * session, ui
|
|||
|
||||
/** rct2: 0x008B001C */
|
||||
static void mini_suspended_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2012,7 +2012,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_down(paint_session * ses
|
|||
session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2036,7 +2036,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_down(paint_session * ses
|
|||
session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2060,7 +2060,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_down(paint_session * ses
|
|||
session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2110,12 +2110,12 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_down(paint_session * ses
|
|||
|
||||
/** rct2: 0x008B002C */
|
||||
static void mini_suspended_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2140,7 +2140,7 @@ static void mini_suspended_rc_track_diag_25_deg_down_to_flat(paint_session * ses
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2165,7 +2165,7 @@ static void mini_suspended_rc_track_diag_25_deg_down_to_flat(paint_session * ses
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2190,7 +2190,7 @@ static void mini_suspended_rc_track_diag_25_deg_down_to_flat(paint_session * ses
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -201,7 +201,7 @@ static const uint32 reverse_freefall_rc_track_pieces_vertical_supports[4] = {
|
|||
};
|
||||
|
||||
static void paint_reverse_freefall_rc_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (direction & 1)
|
||||
{
|
||||
|
@ -222,7 +222,7 @@ static void paint_reverse_freefall_rc_flat(paint_session * session, uint8 rideIn
|
|||
}
|
||||
|
||||
static void paint_reverse_freefall_rc_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
|
||||
|
@ -261,14 +261,14 @@ static void paint_reverse_freefall_rc_station(paint_session * session, uint8 rid
|
|||
paint_util_push_tunnel_right(session, height, TUNNEL_6);
|
||||
}
|
||||
|
||||
track_paint_util_draw_station_platform(session, ride, direction, height, 5, mapElement);
|
||||
track_paint_util_draw_station_platform(session, ride, direction, height, 5, tileElement);
|
||||
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
}
|
||||
|
||||
static void paint_reverse_freefall_rc_slope(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
TESTPAINT_IGNORE_ALL();
|
||||
|
||||
|
@ -360,7 +360,7 @@ static void paint_reverse_freefall_rc_slope(paint_session * session, uint8 rideI
|
|||
}
|
||||
|
||||
static void paint_reverse_freefall_rc_vertical(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 supportsImageId, trackImageId;
|
||||
switch (trackSequence)
|
||||
|
|
|
@ -48,9 +48,9 @@ void vehicle_visual_reverser(paint_session * session, sint32 x, sint32 imageDire
|
|||
|
||||
/** rct2: 0x0086E65C */
|
||||
static void reverser_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -92,7 +92,7 @@ static void reverser_rc_track_flat(paint_session * session, uint8 rideIndex, uin
|
|||
}
|
||||
|
||||
static void reverser_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][3] = {
|
||||
{ 21506, SPR_STATION_BASE_A_SW_NE },
|
||||
|
@ -106,7 +106,7 @@ static void reverser_rc_track_station(paint_session * session, uint8 rideIndex,
|
|||
sub_98199C_rotated(session, direction, imageIds[direction][0] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 27, 2,
|
||||
height, 0, 2, height);
|
||||
wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
|
||||
track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
|
||||
track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -114,9 +114,9 @@ static void reverser_rc_track_station(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x0086E66C */
|
||||
static void reverser_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -182,9 +182,9 @@ static void reverser_rc_track_25_deg_up(paint_session * session, uint8 rideIndex
|
|||
|
||||
/** rct2: 0x0086E67C */
|
||||
static void reverser_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -250,9 +250,9 @@ static void reverser_rc_track_flat_to_25_deg_up(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x0086E68C */
|
||||
static void reverser_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -318,28 +318,28 @@ static void reverser_rc_track_25_deg_up_to_flat(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x0086E69C */
|
||||
static void reverser_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
reverser_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
reverser_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0086E6AC */
|
||||
static void reverser_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
reverser_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
reverser_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0086E6BC */
|
||||
static void reverser_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
reverser_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
reverser_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0086E6CC */
|
||||
static void reverser_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -496,15 +496,15 @@ static void reverser_rc_track_left_quarter_turn_5(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x0086E6DC */
|
||||
static void reverser_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
reverser_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
reverser_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0086E6EC */
|
||||
static void reverser_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -640,7 +640,7 @@ static void reverser_rc_track_s_bend_left(paint_session * session, uint8 rideInd
|
|||
|
||||
/** rct2: 0x0086E6FC */
|
||||
static void reverser_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -776,7 +776,7 @@ static void reverser_rc_track_s_bend_right(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x0086E73C */
|
||||
static void reverser_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -879,15 +879,15 @@ static void reverser_rc_track_left_quarter_turn_3(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x0086E74C */
|
||||
static void reverser_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
reverser_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
reverser_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0086E75C */
|
||||
static void reverser_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -911,7 +911,7 @@ static void reverser_rc_track_brakes(paint_session * session, uint8 rideIndex, u
|
|||
|
||||
/** rct2: 0x0086E76C */
|
||||
static void reverser_rc_track_left_reverser(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1095,7 +1095,7 @@ static void reverser_rc_track_left_reverser(paint_session * session, uint8 rideI
|
|||
|
||||
/** rct2: 0x0086E77C */
|
||||
static void reverser_rc_track_right_reverser(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
|
|
@ -28,9 +28,9 @@
|
|||
|
||||
/** rct2: 0x0077839C */
|
||||
static void side_friction_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -93,7 +93,7 @@ static void side_friction_rc_track_flat(paint_session * session, uint8 rideIndex
|
|||
|
||||
/** rct2: 0x007784AC, 0x007784BC, 0x007784CC */
|
||||
static void side_friction_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4] = {
|
||||
21610,
|
||||
|
@ -105,7 +105,7 @@ static void side_friction_rc_track_station(paint_session * session, uint8 rideIn
|
|||
sub_98197C_rotated(session, direction, imageIds[direction] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 27, 2, height,
|
||||
0, 2, height);
|
||||
wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
|
||||
track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
|
||||
track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -113,9 +113,9 @@ static void side_friction_rc_track_station(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x007783AC */
|
||||
static void side_friction_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -197,9 +197,9 @@ static void side_friction_rc_track_25_deg_up(paint_session * session, uint8 ride
|
|||
|
||||
/** rct2: 0x007783CC */
|
||||
static void side_friction_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -281,9 +281,9 @@ static void side_friction_rc_track_flat_to_25_deg_up(paint_session * session, ui
|
|||
|
||||
/** rct2: 0x007783FC */
|
||||
static void side_friction_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -365,28 +365,28 @@ static void side_friction_rc_track_25_deg_up_to_flat(paint_session * session, ui
|
|||
|
||||
/** rct2: 0x0077840C */
|
||||
static void side_friction_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
side_friction_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
side_friction_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0077842C */
|
||||
static void side_friction_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
side_friction_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
side_friction_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0077845C */
|
||||
static void side_friction_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
side_friction_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
side_friction_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0077846C */
|
||||
static void side_friction_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -583,15 +583,15 @@ static void side_friction_rc_track_left_quarter_turn_5(paint_session * session,
|
|||
|
||||
/** rct2: 0x0077847C */
|
||||
static void side_friction_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
side_friction_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
side_friction_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0077848C */
|
||||
static void side_friction_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -759,7 +759,7 @@ static void side_friction_rc_track_s_bend_left(paint_session * session, uint8 ri
|
|||
|
||||
/** rct2: 0x0077849C */
|
||||
static void side_friction_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -927,7 +927,7 @@ static void side_friction_rc_track_s_bend_right(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x007784DC */
|
||||
static void side_friction_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1054,15 +1054,15 @@ static void side_friction_rc_track_left_quarter_turn_3(paint_session * session,
|
|||
|
||||
/** rct2: 0x007784EC */
|
||||
static void side_friction_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
side_friction_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
side_friction_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x007784FC */
|
||||
static void side_friction_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1090,7 +1090,7 @@ static void side_friction_rc_track_brakes(paint_session * session, uint8 rideInd
|
|||
|
||||
/** rct2: 0x007785DC */
|
||||
static void side_friction_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1258,7 +1258,7 @@ static void side_friction_rc_track_left_eighth_to_diag(paint_session * session,
|
|||
|
||||
/** rct2: 0x007785EC */
|
||||
static void side_friction_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1426,28 +1426,28 @@ static void side_friction_rc_track_right_eighth_to_diag(paint_session * session,
|
|||
|
||||
/** rct2: 0x007785FC */
|
||||
static void side_friction_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
side_friction_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
side_friction_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0077860C */
|
||||
static void side_friction_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
side_friction_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
|
||||
side_friction_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0077850C */
|
||||
static void side_friction_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1471,7 +1471,7 @@ static void side_friction_rc_track_diag_flat(paint_session * session, uint8 ride
|
|||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1519,7 +1519,7 @@ static void side_friction_rc_track_diag_flat(paint_session * session, uint8 ride
|
|||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1567,7 +1567,7 @@ static void side_friction_rc_track_diag_flat(paint_session * session, uint8 ride
|
|||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1595,12 +1595,12 @@ static void side_friction_rc_track_diag_flat(paint_session * session, uint8 ride
|
|||
|
||||
/** rct2: 0x0077853C */
|
||||
static void side_friction_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1624,7 +1624,7 @@ static void side_friction_rc_track_diag_25_deg_up(paint_session * session, uint8
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1672,7 +1672,7 @@ static void side_friction_rc_track_diag_25_deg_up(paint_session * session, uint8
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1720,7 +1720,7 @@ static void side_friction_rc_track_diag_25_deg_up(paint_session * session, uint8
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1748,12 +1748,12 @@ static void side_friction_rc_track_diag_25_deg_up(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x0077851C */
|
||||
static void side_friction_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1777,7 +1777,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_up(paint_session * sessio
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1825,7 +1825,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_up(paint_session * sessio
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1873,7 +1873,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_up(paint_session * sessio
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1901,12 +1901,12 @@ static void side_friction_rc_track_diag_flat_to_25_deg_up(paint_session * sessio
|
|||
|
||||
/** rct2: 0x0077852C */
|
||||
static void side_friction_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1930,7 +1930,7 @@ static void side_friction_rc_track_diag_25_deg_up_to_flat(paint_session * sessio
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1978,7 +1978,7 @@ static void side_friction_rc_track_diag_25_deg_up_to_flat(paint_session * sessio
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2026,7 +2026,7 @@ static void side_friction_rc_track_diag_25_deg_up_to_flat(paint_session * sessio
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2054,12 +2054,12 @@ static void side_friction_rc_track_diag_25_deg_up_to_flat(paint_session * sessio
|
|||
|
||||
/** rct2: 0x0077859C */
|
||||
static void side_friction_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2083,7 +2083,7 @@ static void side_friction_rc_track_diag_25_deg_down(paint_session * session, uin
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2131,7 +2131,7 @@ static void side_friction_rc_track_diag_25_deg_down(paint_session * session, uin
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2179,7 +2179,7 @@ static void side_friction_rc_track_diag_25_deg_down(paint_session * session, uin
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2207,12 +2207,12 @@ static void side_friction_rc_track_diag_25_deg_down(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x0077857C */
|
||||
static void side_friction_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2234,7 +2234,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_down(paint_session * sess
|
|||
}
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2280,7 +2280,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_down(paint_session * sess
|
|||
}
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2326,7 +2326,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_down(paint_session * sess
|
|||
}
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2355,12 +2355,12 @@ static void side_friction_rc_track_diag_flat_to_25_deg_down(paint_session * sess
|
|||
|
||||
/** rct2: 0x0077858C */
|
||||
static void side_friction_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2384,7 +2384,7 @@ static void side_friction_rc_track_diag_25_deg_down_to_flat(paint_session * sess
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2432,7 +2432,7 @@ static void side_friction_rc_track_diag_25_deg_down_to_flat(paint_session * sess
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2480,7 +2480,7 @@ static void side_friction_rc_track_diag_25_deg_down_to_flat(paint_session * sess
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -28,9 +28,9 @@
|
|||
|
||||
/** rct2: 0x008A59A8 */
|
||||
static void steeplechase_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -71,7 +71,7 @@ static void steeplechase_track_flat(paint_session * session, uint8 rideIndex, ui
|
|||
}
|
||||
|
||||
static void steeplechase_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][3] = {
|
||||
{ 28635, SPR_STATION_BASE_B_SW_NE },
|
||||
|
@ -85,7 +85,7 @@ static void steeplechase_track_station(paint_session * session, uint8 rideIndex,
|
|||
sub_98199C_rotated(session, direction, imageIds[direction][0] | session->TrackColours[SCHEME_TRACK], 0, 6, 32, 20, 3,
|
||||
height, 0, 0, height);
|
||||
track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 3);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -93,9 +93,9 @@ static void steeplechase_track_station(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x008A59B8 */
|
||||
static void steeplechase_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -158,9 +158,9 @@ static void steeplechase_track_25_deg_up(paint_session * session, uint8 rideInde
|
|||
|
||||
/** rct2: 0x008A59C8 */
|
||||
static void steeplechase_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -223,9 +223,9 @@ static void steeplechase_track_flat_to_25_deg_up(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x008A59D8 */
|
||||
static void steeplechase_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -288,28 +288,28 @@ static void steeplechase_track_25_deg_up_to_flat(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x008A59E8 */
|
||||
static void steeplechase_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
steeplechase_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
steeplechase_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A59F8 */
|
||||
static void steeplechase_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
steeplechase_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
steeplechase_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A5A08 */
|
||||
static void steeplechase_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
steeplechase_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
steeplechase_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A5A18 */
|
||||
static void steeplechase_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -455,15 +455,15 @@ static void steeplechase_track_left_quarter_turn_5(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x008A5A28 */
|
||||
static void steeplechase_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
steeplechase_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
steeplechase_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A5A38 */
|
||||
static void steeplechase_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -587,7 +587,7 @@ static void steeplechase_track_s_bend_left(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x008A5A48 */
|
||||
static void steeplechase_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -713,7 +713,7 @@ static void steeplechase_track_s_bend_right(paint_session * session, uint8 rideI
|
|||
|
||||
/** rct2: 0x008A5A88 */
|
||||
static void steeplechase_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -811,15 +811,15 @@ static void steeplechase_track_left_quarter_turn_3(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x008A5A98 */
|
||||
static void steeplechase_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
steeplechase_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
steeplechase_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A5AA8 */
|
||||
static void steeplechase_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -842,7 +842,7 @@ static void steeplechase_track_brakes(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x008A5AD8 */
|
||||
static void steeplechase_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -973,7 +973,7 @@ static void steeplechase_track_left_eighth_to_diag(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x008A5AE8 */
|
||||
static void steeplechase_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1104,28 +1104,28 @@ static void steeplechase_track_right_eighth_to_diag(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x008A5AF8 */
|
||||
static void steeplechase_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
steeplechase_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
steeplechase_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A5B08 */
|
||||
static void steeplechase_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
steeplechase_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
|
||||
steeplechase_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A5AC8 */
|
||||
static void steeplechase_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1150,7 +1150,7 @@ static void steeplechase_track_diag_flat(paint_session * session, uint8 rideInde
|
|||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1175,7 +1175,7 @@ static void steeplechase_track_diag_flat(paint_session * session, uint8 rideInde
|
|||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1200,7 +1200,7 @@ static void steeplechase_track_diag_flat(paint_session * session, uint8 rideInde
|
|||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1257,12 +1257,12 @@ static void steeplechase_track_diag_flat(paint_session * session, uint8 rideInde
|
|||
|
||||
/** rct2: 0x008A5B38 */
|
||||
static void steeplechase_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1287,7 +1287,7 @@ static void steeplechase_track_diag_25_deg_up(paint_session * session, uint8 rid
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1312,7 +1312,7 @@ static void steeplechase_track_diag_25_deg_up(paint_session * session, uint8 rid
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1337,7 +1337,7 @@ static void steeplechase_track_diag_25_deg_up(paint_session * session, uint8 rid
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1394,12 +1394,12 @@ static void steeplechase_track_diag_25_deg_up(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x008A5B18 */
|
||||
static void steeplechase_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1424,7 +1424,7 @@ static void steeplechase_track_diag_flat_to_25_deg_up(paint_session * session, u
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1449,7 +1449,7 @@ static void steeplechase_track_diag_flat_to_25_deg_up(paint_session * session, u
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1474,7 +1474,7 @@ static void steeplechase_track_diag_flat_to_25_deg_up(paint_session * session, u
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1531,12 +1531,12 @@ static void steeplechase_track_diag_flat_to_25_deg_up(paint_session * session, u
|
|||
|
||||
/** rct2: 0x008A5B28 */
|
||||
static void steeplechase_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1561,7 +1561,7 @@ static void steeplechase_track_diag_25_deg_up_to_flat(paint_session * session, u
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1586,7 +1586,7 @@ static void steeplechase_track_diag_25_deg_up_to_flat(paint_session * session, u
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1611,7 +1611,7 @@ static void steeplechase_track_diag_25_deg_up_to_flat(paint_session * session, u
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1668,12 +1668,12 @@ static void steeplechase_track_diag_25_deg_up_to_flat(paint_session * session, u
|
|||
|
||||
/** rct2: 0x008A5B68 */
|
||||
static void steeplechase_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1698,7 +1698,7 @@ static void steeplechase_track_diag_25_deg_down(paint_session * session, uint8 r
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1723,7 +1723,7 @@ static void steeplechase_track_diag_25_deg_down(paint_session * session, uint8 r
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1748,7 +1748,7 @@ static void steeplechase_track_diag_25_deg_down(paint_session * session, uint8 r
|
|||
paint_util_set_general_support_height(session, height + 56, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1805,12 +1805,12 @@ static void steeplechase_track_diag_25_deg_down(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x008A5B48 */
|
||||
static void steeplechase_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1834,7 +1834,7 @@ static void steeplechase_track_diag_flat_to_25_deg_down(paint_session * session,
|
|||
session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1858,7 +1858,7 @@ static void steeplechase_track_diag_flat_to_25_deg_down(paint_session * session,
|
|||
session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1882,7 +1882,7 @@ static void steeplechase_track_diag_flat_to_25_deg_down(paint_session * session,
|
|||
session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1940,12 +1940,12 @@ static void steeplechase_track_diag_flat_to_25_deg_down(paint_session * session,
|
|||
|
||||
/** rct2: 0x008A5B58 */
|
||||
static void steeplechase_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1970,7 +1970,7 @@ static void steeplechase_track_diag_25_deg_down_to_flat(paint_session * session,
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1995,7 +1995,7 @@ static void steeplechase_track_diag_25_deg_down_to_flat(paint_session * session,
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2020,7 +2020,7 @@ static void steeplechase_track_diag_25_deg_down_to_flat(paint_session * session,
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2077,7 +2077,7 @@ static void steeplechase_track_diag_25_deg_down_to_flat(paint_session * session,
|
|||
|
||||
/** rct2: 0x008A5AB8 */
|
||||
static void steeplechase_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
|
|
@ -28,9 +28,9 @@
|
|||
|
||||
/** rct2: 0x008A8958 */
|
||||
static void suspended_swinging_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -76,7 +76,7 @@ static void suspended_swinging_rc_track_flat(paint_session * session, uint8 ride
|
|||
|
||||
/** rct2: 0x008A8AA8, 0x008A8AB8, 0x008A8AC8 */
|
||||
static void suspended_swinging_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][3] = {
|
||||
{ SPR_STATION_BASE_C_SW_NE, 25963, SPR_STATION_INVERTED_BAR_D_SW_NE },
|
||||
|
@ -92,7 +92,7 @@ static void suspended_swinging_rc_track_station(paint_session * session, uint8 r
|
|||
sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 3,
|
||||
height + 29, 0, 6, height + 29);
|
||||
track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
|
||||
track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement,
|
||||
track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement,
|
||||
STATION_VARIANT_TALL);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_9);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
|
@ -101,9 +101,9 @@ static void suspended_swinging_rc_track_station(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x008A8968 */
|
||||
static void suspended_swinging_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -186,7 +186,7 @@ static void suspended_swinging_rc_track_25_deg_up(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x008A8978 */
|
||||
static void suspended_swinging_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -222,9 +222,9 @@ static void suspended_swinging_rc_track_60_deg_up(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x008A8988 */
|
||||
static void suspended_swinging_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -307,7 +307,7 @@ static void suspended_swinging_rc_track_flat_to_25_deg_up(paint_session * sessio
|
|||
|
||||
/** rct2: 0x008A8998 */
|
||||
static void suspended_swinging_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -347,9 +347,9 @@ static void suspended_swinging_rc_track_25_deg_up_to_60_deg_up(paint_session * s
|
|||
|
||||
/** rct2: 0x008A89A8 */
|
||||
static void suspended_swinging_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -440,9 +440,9 @@ static void suspended_swinging_rc_track_60_deg_up_to_25_deg_up(paint_session * s
|
|||
|
||||
/** rct2: 0x008A89B8 */
|
||||
static void suspended_swinging_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -525,53 +525,53 @@ static void suspended_swinging_rc_track_25_deg_up_to_flat(paint_session * sessio
|
|||
|
||||
/** rct2: 0x008A89C8 */
|
||||
static void suspended_swinging_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
suspended_swinging_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
suspended_swinging_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A89D8 */
|
||||
static void suspended_swinging_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
suspended_swinging_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
suspended_swinging_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A89E8 */
|
||||
static void suspended_swinging_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
suspended_swinging_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
suspended_swinging_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A89F8 */
|
||||
static void suspended_swinging_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
suspended_swinging_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A8A08 */
|
||||
static void suspended_swinging_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
suspended_swinging_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A8A18 */
|
||||
static void suspended_swinging_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
suspended_swinging_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
suspended_swinging_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A8A28 */
|
||||
static void suspended_swinging_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -726,16 +726,16 @@ static void suspended_swinging_rc_track_left_quarter_turn_5(paint_session * sess
|
|||
|
||||
/** rct2: 0x008A8A38 */
|
||||
static void suspended_swinging_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
suspended_swinging_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
suspended_swinging_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A8A48 */
|
||||
static void suspended_swinging_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -877,7 +877,7 @@ static void suspended_swinging_rc_track_left_quarter_turn_5_25_deg_up(paint_sess
|
|||
/** rct2: 0x008A8A58 */
|
||||
static void suspended_swinging_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1019,26 +1019,26 @@ static void suspended_swinging_rc_track_right_quarter_turn_5_25_deg_up(paint_ses
|
|||
/** rct2: 0x008A8A68 */
|
||||
static void suspended_swinging_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
suspended_swinging_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A8A78 */
|
||||
static void suspended_swinging_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
suspended_swinging_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A8A88 */
|
||||
static void suspended_swinging_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1176,7 +1176,7 @@ static void suspended_swinging_rc_track_s_bend_left(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x008A8A98 */
|
||||
static void suspended_swinging_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1314,7 +1314,7 @@ static void suspended_swinging_rc_track_s_bend_right(paint_session * session, ui
|
|||
|
||||
/** rct2: 0x008A8AD8 */
|
||||
static void suspended_swinging_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1418,16 +1418,16 @@ static void suspended_swinging_rc_track_left_quarter_turn_3(paint_session * sess
|
|||
|
||||
/** rct2: 0x008A8AE8 */
|
||||
static void suspended_swinging_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
suspended_swinging_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
suspended_swinging_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A8AF8 */
|
||||
static void suspended_swinging_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1504,7 +1504,7 @@ static void suspended_swinging_rc_track_left_quarter_turn_3_25_deg_up(paint_sess
|
|||
/** rct2: 0x008A8B08 */
|
||||
static void suspended_swinging_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1581,26 +1581,26 @@ static void suspended_swinging_rc_track_right_quarter_turn_3_25_deg_up(paint_ses
|
|||
/** rct2: 0x008A8B18 */
|
||||
static void suspended_swinging_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
suspended_swinging_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A8B28 */
|
||||
static void suspended_swinging_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
suspended_swinging_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A8B38 */
|
||||
static void suspended_swinging_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -1630,7 +1630,7 @@ static void suspended_swinging_rc_track_brakes(paint_session * session, uint8 ri
|
|||
/** rct2: 0x008A8B48 */
|
||||
static void suspended_swinging_rc_track_left_quarter_helix_large_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1791,7 +1791,7 @@ static void suspended_swinging_rc_track_left_quarter_helix_large_up(paint_sessio
|
|||
/** rct2: 0x008A8B58 */
|
||||
static void suspended_swinging_rc_track_right_quarter_helix_large_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -1952,7 +1952,7 @@ static void suspended_swinging_rc_track_right_quarter_helix_large_up(paint_sessi
|
|||
/** rct2: 0x008A8B68 */
|
||||
static void suspended_swinging_rc_track_left_quarter_helix_large_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2113,7 +2113,7 @@ static void suspended_swinging_rc_track_left_quarter_helix_large_down(paint_sess
|
|||
/** rct2: 0x008A8B78 */
|
||||
static void suspended_swinging_rc_track_right_quarter_helix_large_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2273,7 +2273,7 @@ static void suspended_swinging_rc_track_right_quarter_helix_large_down(paint_ses
|
|||
|
||||
/** rct2: 0x008A8B88 */
|
||||
static void suspended_swinging_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2417,7 +2417,7 @@ static void suspended_swinging_rc_track_left_eighth_to_diag(paint_session * sess
|
|||
|
||||
/** rct2: 0x008A8B98 */
|
||||
static void suspended_swinging_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2561,30 +2561,30 @@ static void suspended_swinging_rc_track_right_eighth_to_diag(paint_session * ses
|
|||
|
||||
/** rct2: 0x008A8BA8 */
|
||||
static void suspended_swinging_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
suspended_swinging_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A8BB8 */
|
||||
static void suspended_swinging_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
|
||||
suspended_swinging_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
|
||||
suspended_swinging_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A8BC8 */
|
||||
static void suspended_swinging_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2609,7 +2609,7 @@ static void suspended_swinging_rc_track_diag_flat(paint_session * session, uint8
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2634,7 +2634,7 @@ static void suspended_swinging_rc_track_diag_flat(paint_session * session, uint8
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2659,7 +2659,7 @@ static void suspended_swinging_rc_track_diag_flat(paint_session * session, uint8
|
|||
paint_util_set_general_support_height(session, height + 48, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2709,12 +2709,12 @@ static void suspended_swinging_rc_track_diag_flat(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x008A8BF8 */
|
||||
static void suspended_swinging_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2739,7 +2739,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up(paint_session * session,
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2764,7 +2764,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up(paint_session * session,
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2789,7 +2789,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up(paint_session * session,
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2839,7 +2839,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x008A8C58 */
|
||||
static void suspended_swinging_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -2917,12 +2917,12 @@ static void suspended_swinging_rc_track_diag_60_deg_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x008A8BD8 */
|
||||
static void suspended_swinging_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2947,7 +2947,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_up(paint_session * s
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2972,7 +2972,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_up(paint_session * s
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -2997,7 +2997,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_up(paint_session * s
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3048,7 +3048,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_up(paint_session * s
|
|||
/** rct2: 0x008A8C38 */
|
||||
static void suspended_swinging_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3127,7 +3127,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up_to_60_deg_up(paint_sessio
|
|||
/** rct2: 0x008A8C48 */
|
||||
static void suspended_swinging_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3205,12 +3205,12 @@ static void suspended_swinging_rc_track_diag_60_deg_up_to_25_deg_up(paint_sessio
|
|||
|
||||
/** rct2: 0x008A8BE8 */
|
||||
static void suspended_swinging_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3235,7 +3235,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up_to_flat(paint_session * s
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3260,7 +3260,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up_to_flat(paint_session * s
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3285,7 +3285,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up_to_flat(paint_session * s
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3335,12 +3335,12 @@ static void suspended_swinging_rc_track_diag_25_deg_up_to_flat(paint_session * s
|
|||
|
||||
/** rct2: 0x008A8C28 */
|
||||
static void suspended_swinging_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3365,7 +3365,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down(paint_session * session
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3390,7 +3390,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down(paint_session * session
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3415,7 +3415,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down(paint_session * session
|
|||
paint_util_set_general_support_height(session, height + 72, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3465,7 +3465,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down(paint_session * session
|
|||
|
||||
/** rct2: 0x008A8C88 */
|
||||
static void suspended_swinging_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3522,12 +3522,12 @@ static void suspended_swinging_rc_track_diag_60_deg_down(paint_session * session
|
|||
|
||||
/** rct2: 0x008A8C08 */
|
||||
static void suspended_swinging_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3551,7 +3551,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_down(paint_session *
|
|||
session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3575,7 +3575,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_down(paint_session *
|
|||
session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3599,7 +3599,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_down(paint_session *
|
|||
session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3650,7 +3650,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_down(paint_session *
|
|||
/** rct2: 0x008A8C68 */
|
||||
static void suspended_swinging_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3729,7 +3729,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down_to_60_deg_down(paint_se
|
|||
/** rct2: 0x008A8C78 */
|
||||
static void suspended_swinging_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
|
@ -3807,12 +3807,12 @@ static void suspended_swinging_rc_track_diag_60_deg_down_to_25_deg_down(paint_se
|
|||
|
||||
/** rct2: 0x008A8C18 */
|
||||
static void suspended_swinging_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 0:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3837,7 +3837,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down_to_flat(paint_session *
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 1:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3862,7 +3862,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down_to_flat(paint_session *
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 2:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3887,7 +3887,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down_to_flat(paint_session *
|
|||
paint_util_set_general_support_height(session, height + 64, 0x20);
|
||||
break;
|
||||
case 3:
|
||||
if (track_element_is_lift_hill(mapElement))
|
||||
if (track_element_is_lift_hill(tileElement))
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -3937,7 +3937,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down_to_flat(paint_session *
|
|||
|
||||
/** rct2: 0x008A8B38 */
|
||||
static void suspended_swinging_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
|
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -231,10 +231,10 @@ void vehicle_visual_virginia_reel(paint_session * session, sint32 x, sint32 imag
|
|||
|
||||
/** rct2: 0x00811264 */
|
||||
static void paint_virginia_reel_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
const uint32 * sprites = virginia_reel_track_pieces_flat;
|
||||
if (mapElement->type & 0x80)
|
||||
if (tileElement->type & 0x80)
|
||||
{
|
||||
sprites = virginia_reel_track_pieces_flat_lift_hill;
|
||||
}
|
||||
|
@ -259,10 +259,10 @@ static void paint_virginia_reel_track_flat(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x00811274 */
|
||||
static void paint_virginia_reel_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
const uint32 * sprites = virginia_reel_track_pieces_25_deg_up;
|
||||
if (mapElement->type & 0x80)
|
||||
if (tileElement->type & 0x80)
|
||||
{
|
||||
sprites = virginia_reel_track_pieces_25_deg_up_lift_hill;
|
||||
}
|
||||
|
@ -310,10 +310,10 @@ static void paint_virginia_reel_track_25_deg_up(paint_session * session, uint8 r
|
|||
|
||||
/** rct2: 0x00811294 */
|
||||
static void paint_virginia_reel_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
const uint32 * sprites = virginia_reel_track_pieces_flat_to_25_deg_up;
|
||||
if (mapElement->type & 0x80)
|
||||
if (tileElement->type & 0x80)
|
||||
{
|
||||
sprites = virginia_reel_track_pieces_flat_to_25_deg_up_lift_hill;
|
||||
}
|
||||
|
@ -356,10 +356,10 @@ static void paint_virginia_reel_track_flat_to_25_deg_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x00811294 */
|
||||
static void paint_virginia_reel_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
const uint32 * sprites = virginia_reel_track_pieces_25_deg_up_to_flat;
|
||||
if (mapElement->type & 0x80)
|
||||
if (tileElement->type & 0x80)
|
||||
{
|
||||
sprites = virginia_reel_track_pieces_25_deg_up_to_flat_lift_hill;
|
||||
}
|
||||
|
@ -407,28 +407,28 @@ static void paint_virginia_reel_track_25_deg_up_to_flat(paint_session * session,
|
|||
|
||||
/** rct2: 0x008112A4 */
|
||||
static void paint_virginia_reel_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_virginia_reel_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_virginia_reel_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008112B4 */
|
||||
static void paint_virginia_reel_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_virginia_reel_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_virginia_reel_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008112C4 */
|
||||
static void paint_virginia_reel_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_virginia_reel_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_virginia_reel_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008112D4, 0x008112E4, 0x008112F4 */
|
||||
static void paint_virginia_reel_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
|
||||
|
@ -454,7 +454,7 @@ static void paint_virginia_reel_station(paint_session * session, uint8 rideIndex
|
|||
}
|
||||
|
||||
wooden_a_supports_paint_setup(session, (direction & 1), 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -464,7 +464,7 @@ static const uint8 virginia_reel_left_quarter_turn_supports[] = { 5, 2, 3, 4 };
|
|||
|
||||
/** rct2: 0x00811304 */
|
||||
static void paint_virginia_reel_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
track_paint_util_left_quarter_turn_3_tiles_paint(
|
||||
session, 2, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
|
||||
|
@ -492,16 +492,16 @@ static const uint8 virginia_reel_right_quarter_turn_3_tiles_to_left_turn_map[] =
|
|||
|
||||
/** rct2: 0x00811314 */
|
||||
static void paint_virginia_reel_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = virginia_reel_right_quarter_turn_3_tiles_to_left_turn_map[trackSequence];
|
||||
paint_virginia_reel_track_left_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 3) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00811324 */
|
||||
static void paint_virginia_reel_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
track_paint_util_left_quarter_turn_1_tile_paint(session, 2, height, 0, direction, session->TrackColours[SCHEME_TRACK],
|
||||
virginia_reel_track_pieces_flat_quarter_turn_1_tile,
|
||||
|
@ -533,10 +533,10 @@ static void paint_virginia_reel_track_left_quarter_turn_1_tile(paint_session * s
|
|||
|
||||
/** rct2: 0x00811334 */
|
||||
static void paint_virginia_reel_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_virginia_reel_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -171,7 +171,7 @@ static const uint32 _wild_mouse_block_brakes_image_ids[4] = {
|
|||
|
||||
/** rct2: 0x0078B1E4 */
|
||||
static void wild_mouse_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_WILD_MOUSE_FLAT_SW_NE, SPR_WILD_MOUSE_FLAT_CHAIN_SW_NE },
|
||||
|
@ -180,7 +180,7 @@ static void wild_mouse_track_flat(paint_session * session, uint8 rideIndex, uint
|
|||
{ SPR_WILD_MOUSE_FLAT_NW_SE, SPR_WILD_MOUSE_FLAT_CHAIN_SE_NW },
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
|
||||
if (track_paint_util_should_paint_supports(session->MapPosition))
|
||||
|
@ -194,7 +194,7 @@ static void wild_mouse_track_flat(paint_session * session, uint8 rideIndex, uint
|
|||
}
|
||||
|
||||
static void wild_mouse_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 baseImageIds[4] = {
|
||||
SPR_STATION_BASE_B_SW_NE,
|
||||
|
@ -203,7 +203,7 @@ static void wild_mouse_track_station(paint_session * session, uint8 rideIndex, u
|
|||
SPR_STATION_BASE_B_NW_SE,
|
||||
};
|
||||
|
||||
sint32 trackType = mapElement->properties.track.type;
|
||||
sint32 trackType = tileElement->properties.track.type;
|
||||
sub_98197C_rotated(session, direction, baseImageIds[direction] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 28, 2,
|
||||
height - 2, 0, 2, height);
|
||||
if (trackType == TRACK_ELEM_END_STATION)
|
||||
|
@ -218,7 +218,7 @@ static void wild_mouse_track_station(paint_session * session, uint8 rideIndex, u
|
|||
0, 32, 20, 2, height, 0, 0, height);
|
||||
}
|
||||
track_paint_util_draw_station_metal_supports(session, direction, height, session->TrackColours[SCHEME_SUPPORTS]);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -226,7 +226,7 @@ static void wild_mouse_track_station(paint_session * session, uint8 rideIndex, u
|
|||
|
||||
/** rct2: 0x0078B1F4 */
|
||||
static void wild_mouse_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_WILD_MOUSE_25_DEG_SW_NE, SPR_WILD_MOUSE_25_DEG_CHAIN_SW_NE },
|
||||
|
@ -235,7 +235,7 @@ static void wild_mouse_track_25_deg_up(paint_session * session, uint8 rideIndex,
|
|||
{ SPR_WILD_MOUSE_25_DEG_SE_NW, SPR_WILD_MOUSE_25_DEG_CHAIN_SE_NW },
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
|
||||
if (track_paint_util_should_paint_supports(session->MapPosition))
|
||||
|
@ -257,7 +257,7 @@ static void wild_mouse_track_25_deg_up(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x0078B204 */
|
||||
static void wild_mouse_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_WILD_MOUSE_60_DEG_SW_NE, SPR_WILD_MOUSE_60_DEG_CHAIN_SW_NE },
|
||||
|
@ -266,7 +266,7 @@ static void wild_mouse_track_60_deg_up(paint_session * session, uint8 rideIndex,
|
|||
{ SPR_WILD_MOUSE_60_DEG_SE_NW, SPR_WILD_MOUSE_60_DEG_CHAIN_SE_NW },
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
if (direction == 0 || direction == 3)
|
||||
{
|
||||
|
@ -302,7 +302,7 @@ static void wild_mouse_track_60_deg_up(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x0078B214 */
|
||||
static void wild_mouse_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_WILD_MOUSE_FLAT_TO_25_DEG_SW_NE, SPR_WILD_MOUSE_FLAT_TO_25_DEG_CHAIN_SW_NE },
|
||||
|
@ -311,7 +311,7 @@ static void wild_mouse_track_flat_to_25_deg_up(paint_session * session, uint8 ri
|
|||
{ SPR_WILD_MOUSE_FLAT_TO_25_DEG_SE_NW, SPR_WILD_MOUSE_FLAT_TO_25_DEG_CHAIN_SE_NW },
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
|
||||
if (track_paint_util_should_paint_supports(session->MapPosition))
|
||||
|
@ -333,7 +333,7 @@ static void wild_mouse_track_flat_to_25_deg_up(paint_session * session, uint8 ri
|
|||
|
||||
/** rct2: 0x0078B224 */
|
||||
static void wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_WILD_MOUSE_25_DEG_TO_60_DEG_SW_NE, SPR_WILD_MOUSE_25_DEG_TO_60_DEG_CHAIN_SW_NE },
|
||||
|
@ -348,7 +348,7 @@ static void wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * session, uin
|
|||
{ 0, 0 },
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
uint32 frontImageId = frontImageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
if (direction == 0 || direction == 3)
|
||||
|
@ -379,7 +379,7 @@ static void wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x0078B234 */
|
||||
static void wild_mouse_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_WILD_MOUSE_60_DEG_TO_25_DEG_SW_NE, SPR_WILD_MOUSE_60_DEG_TO_25_DEG_CHAIN_SW_NE },
|
||||
|
@ -394,7 +394,7 @@ static void wild_mouse_track_60_deg_up_to_25_deg_up(paint_session * session, uin
|
|||
{ 0, 0 },
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
uint32 frontImageId = frontImageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
if (direction == 0 || direction == 3)
|
||||
|
@ -425,7 +425,7 @@ static void wild_mouse_track_60_deg_up_to_25_deg_up(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x0078B244 */
|
||||
static void wild_mouse_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_WILD_MOUSE_25_DEG_TO_FLAT_SW_NE, SPR_WILD_MOUSE_25_DEG_TO_FLAT_CHAIN_SW_NE },
|
||||
|
@ -434,7 +434,7 @@ static void wild_mouse_track_25_deg_up_to_flat(paint_session * session, uint8 ri
|
|||
{ SPR_WILD_MOUSE_25_DEG_TO_FLAT_SE_NW, SPR_WILD_MOUSE_25_DEG_TO_FLAT_CHAIN_SE_NW },
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
|
||||
if (track_paint_util_should_paint_supports(session->MapPosition))
|
||||
|
@ -456,48 +456,48 @@ static void wild_mouse_track_25_deg_up_to_flat(paint_session * session, uint8 ri
|
|||
|
||||
/** rct2: 0x0078B254 */
|
||||
static void wild_mouse_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wild_mouse_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wild_mouse_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0078B264 */
|
||||
static void wild_mouse_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wild_mouse_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wild_mouse_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0078B274 */
|
||||
static void wild_mouse_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wild_mouse_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wild_mouse_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0078B284 */
|
||||
static void wild_mouse_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wild_mouse_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wild_mouse_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0078B294 */
|
||||
static void wild_mouse_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wild_mouse_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wild_mouse_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0078B2A4 */
|
||||
static void wild_mouse_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wild_mouse_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wild_mouse_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
static void wild_mouse_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const sprite_bb imageIds[4][3] = {
|
||||
{
|
||||
|
@ -552,7 +552,7 @@ static void wild_mouse_track_right_quarter_turn_3(paint_session * session, uint8
|
|||
}
|
||||
|
||||
static void wild_mouse_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const sprite_bb imageIds[4][2] = {
|
||||
{
|
||||
|
@ -609,16 +609,16 @@ static void wild_mouse_track_right_quarter_turn_3_25_deg_down(paint_session * se
|
|||
}
|
||||
|
||||
static void wild_mouse_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
wild_mouse_track_right_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, (direction + 1) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0078B314 */
|
||||
static void wild_mouse_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const sprite_bb imageIds[4][2] = {
|
||||
{
|
||||
|
@ -684,22 +684,22 @@ static void wild_mouse_track_right_quarter_turn_3_25_deg_up(paint_session * sess
|
|||
|
||||
/** rct2: 0x0078B324 */
|
||||
static void wild_mouse_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
wild_mouse_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
|
||||
wild_mouse_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
static void wild_mouse_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
wild_mouse_track_right_quarter_turn_3(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
|
||||
wild_mouse_track_right_quarter_turn_3(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0078B394 */
|
||||
static void wild_mouse_track_left_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4] = {
|
||||
SPR_WILD_MOUSE_QUARTER_TURN_1_SW_NE,
|
||||
|
@ -733,14 +733,14 @@ static void wild_mouse_track_left_quarter_turn_1(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x0078B3A4 */
|
||||
static void wild_mouse_track_right_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wild_mouse_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
wild_mouse_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0078B354 */
|
||||
static void wild_mouse_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_WILD_MOUSE_FLAT_TO_60_DEG_SW_NE, SPR_WILD_MOUSE_FLAT_TO_60_DEG_CHAIN_SW_NE },
|
||||
|
@ -755,7 +755,7 @@ static void wild_mouse_track_flat_to_60_deg_up(paint_session * session, uint8 ri
|
|||
{ 0, 0 },
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
uint32 frontImageId = frontImageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
if (direction == 0 || direction == 3)
|
||||
|
@ -786,7 +786,7 @@ static void wild_mouse_track_flat_to_60_deg_up(paint_session * session, uint8 ri
|
|||
|
||||
/** rct2: 0x0078B364 */
|
||||
static void wild_mouse_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_WILD_MOUSE_60_DEG_TO_FLAT_SW_NE, SPR_WILD_MOUSE_60_DEG_TO_FLAT_CHAIN_SW_NE },
|
||||
|
@ -801,7 +801,7 @@ static void wild_mouse_track_60_deg_up_to_flat(paint_session * session, uint8 ri
|
|||
{ 0, 0 },
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
uint32 frontImageId = frontImageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
|
||||
if (direction == 0 || direction == 3)
|
||||
|
@ -839,21 +839,21 @@ static void wild_mouse_track_60_deg_up_to_flat(paint_session * session, uint8 ri
|
|||
|
||||
/** rct2: 0x0078B374 */
|
||||
static void wild_mouse_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wild_mouse_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wild_mouse_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0078B384 */
|
||||
static void wild_mouse_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wild_mouse_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wild_mouse_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0078B344 */
|
||||
static void wild_mouse_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId = _wild_mouse_brakes_image_ids[direction] | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
|
||||
|
@ -869,7 +869,7 @@ static void wild_mouse_track_brakes(paint_session * session, uint8 rideIndex, ui
|
|||
|
||||
/** rct2: 0x0078B3C4 */
|
||||
static void wild_mouse_track_rotation_control_toggle(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4] = {
|
||||
SPR_WILD_MOUSE_ROTATION_CONTROL_TOGGLE_SW_NE,
|
||||
|
@ -892,7 +892,7 @@ static void wild_mouse_track_rotation_control_toggle(paint_session * session, ui
|
|||
|
||||
/** rct2: 0x0078B3B4 */
|
||||
static void wild_mouse_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId = _wild_mouse_block_brakes_image_ids[direction] | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -130,7 +130,7 @@ enum
|
|||
|
||||
/** rct2: 0x008A5464 */
|
||||
static void wooden_wild_mouse_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4] = {
|
||||
SPR_WOODEN_WILD_MOUSE_FLAT_SW_NE,
|
||||
|
@ -153,7 +153,7 @@ static void wooden_wild_mouse_track_flat(paint_session * session, uint8 rideInde
|
|||
}
|
||||
|
||||
static void wooden_wild_mouse_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4][2] = {
|
||||
{ SPR_WOODEN_WILD_MOUSE_FLAT_SW_NE, SPR_STATION_BASE_B_SW_NE },
|
||||
|
@ -167,7 +167,7 @@ static void wooden_wild_mouse_track_station(paint_session * session, uint8 rideI
|
|||
sub_98199C_rotated(session, direction, imageIds[direction][0] | session->TrackColours[SCHEME_TRACK], 0, 6, 32, 20, 1,
|
||||
height, 0, 0, height);
|
||||
wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -175,7 +175,7 @@ static void wooden_wild_mouse_track_station(paint_session * session, uint8 rideI
|
|||
|
||||
/** rct2: 0x008A5474 */
|
||||
static void wooden_wild_mouse_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[2][4] = {
|
||||
{
|
||||
|
@ -192,7 +192,7 @@ static void wooden_wild_mouse_track_25_deg_up(paint_session * session, uint8 rid
|
|||
},
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[isChained][direction] | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C_rotated(session, direction, imageId, 0, 2, 32, 25, 1, height, 0, 3, height);
|
||||
|
||||
|
@ -213,7 +213,7 @@ static void wooden_wild_mouse_track_25_deg_up(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x008A5484 */
|
||||
static void wooden_wild_mouse_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[2][4] = {
|
||||
{
|
||||
|
@ -230,7 +230,7 @@ static void wooden_wild_mouse_track_60_deg_up(paint_session * session, uint8 rid
|
|||
},
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[isChained][direction] | session->TrackColours[SCHEME_TRACK];
|
||||
if (direction == 0 || direction == 3)
|
||||
{
|
||||
|
@ -259,7 +259,7 @@ static void wooden_wild_mouse_track_60_deg_up(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x008A5494 */
|
||||
static void wooden_wild_mouse_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[2][4] = {
|
||||
{
|
||||
|
@ -276,7 +276,7 @@ static void wooden_wild_mouse_track_flat_to_25_deg_up(paint_session * session, u
|
|||
},
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[isChained][direction] | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C_rotated(session, direction, imageId, 0, 2, 32, 25, 1, height, 0, 3, height);
|
||||
|
||||
|
@ -297,7 +297,7 @@ static void wooden_wild_mouse_track_flat_to_25_deg_up(paint_session * session, u
|
|||
|
||||
/** rct2: 0x008A54A4 */
|
||||
static void wooden_wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[2][4][2] = {
|
||||
{
|
||||
|
@ -314,7 +314,7 @@ static void wooden_wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * sessi
|
|||
},
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId;
|
||||
if (direction == 0 || direction == 3)
|
||||
{
|
||||
|
@ -346,7 +346,7 @@ static void wooden_wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * sessi
|
|||
}
|
||||
|
||||
static void wooden_wild_mouse_track_60_deg_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[2][4][2] = {
|
||||
{
|
||||
|
@ -363,7 +363,7 @@ static void wooden_wild_mouse_track_60_deg_to_25_deg_up(paint_session * session,
|
|||
},
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId;
|
||||
if (direction == 0 || direction == 3)
|
||||
{
|
||||
|
@ -396,7 +396,7 @@ static void wooden_wild_mouse_track_60_deg_to_25_deg_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x008A54C4 */
|
||||
static void wooden_wild_mouse_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[2][4] = {
|
||||
{
|
||||
|
@ -413,7 +413,7 @@ static void wooden_wild_mouse_track_25_deg_up_to_flat(paint_session * session, u
|
|||
},
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId = imageIds[isChained][direction] | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C_rotated(session, direction, imageId, 0, 2, 32, 25, 1, height, 0, 3, height);
|
||||
|
||||
|
@ -434,48 +434,48 @@ static void wooden_wild_mouse_track_25_deg_up_to_flat(paint_session * session, u
|
|||
|
||||
/** rct2: 0x008A54D4 */
|
||||
static void wooden_wild_mouse_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wooden_wild_mouse_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wooden_wild_mouse_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A54E4 */
|
||||
static void wooden_wild_mouse_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wooden_wild_mouse_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wooden_wild_mouse_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A54F4 */
|
||||
static void wooden_wild_mouse_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wooden_wild_mouse_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wooden_wild_mouse_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A5504 */
|
||||
static void wooden_wild_mouse_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wooden_wild_mouse_track_60_deg_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wooden_wild_mouse_track_60_deg_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A5514 */
|
||||
static void wooden_wild_mouse_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wooden_wild_mouse_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wooden_wild_mouse_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A5524 */
|
||||
static void wooden_wild_mouse_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wooden_wild_mouse_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wooden_wild_mouse_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
static void wooden_wild_mouse_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const sprite_bb imageIds[4][3] = {
|
||||
{
|
||||
|
@ -531,14 +531,14 @@ static void wooden_wild_mouse_track_right_quarter_turn_3(paint_session * session
|
|||
}
|
||||
|
||||
static void wooden_wild_mouse_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
wooden_wild_mouse_track_right_quarter_turn_3(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
|
||||
wooden_wild_mouse_track_right_quarter_turn_3(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
static void wooden_wild_mouse_track_left_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[4] = {
|
||||
SPR_WOODEN_WILD_MOUSE_QUARTER_TURN_1_SW_NE,
|
||||
|
@ -572,14 +572,14 @@ static void wooden_wild_mouse_track_left_quarter_turn_1(paint_session * session,
|
|||
|
||||
/** rct2: 0x008A55D4 */
|
||||
static void wooden_wild_mouse_track_right_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wooden_wild_mouse_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
|
||||
wooden_wild_mouse_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A55E4 */
|
||||
static void wooden_wild_mouse_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[2][4][2] = {
|
||||
{
|
||||
|
@ -596,7 +596,7 @@ static void wooden_wild_mouse_track_flat_to_60_deg_up(paint_session * session, u
|
|||
},
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId;
|
||||
if (direction == 0 || direction == 3)
|
||||
{
|
||||
|
@ -628,7 +628,7 @@ static void wooden_wild_mouse_track_flat_to_60_deg_up(paint_session * session, u
|
|||
|
||||
/** rct2: 0x008A55F4 */
|
||||
static void wooden_wild_mouse_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
static const uint32 imageIds[2][4][2] = {
|
||||
{
|
||||
|
@ -645,7 +645,7 @@ static void wooden_wild_mouse_track_60_deg_up_to_flat(paint_session * session, u
|
|||
},
|
||||
};
|
||||
|
||||
uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
|
||||
uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
|
||||
uint32 imageId;
|
||||
if (direction == 0 || direction == 3)
|
||||
{
|
||||
|
@ -677,16 +677,16 @@ static void wooden_wild_mouse_track_60_deg_up_to_flat(paint_session * session, u
|
|||
|
||||
/** rct2: 0x008A5604 */
|
||||
static void wooden_wild_mouse_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wooden_wild_mouse_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wooden_wild_mouse_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x008A5614 */
|
||||
static void wooden_wild_mouse_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
wooden_wild_mouse_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
|
||||
wooden_wild_mouse_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
|
||||
}
|
||||
|
||||
TRACK_PAINT_FUNCTION get_track_paint_function_wooden_wild_mouse(sint32 trackType, sint32 direction)
|
||||
|
|
|
@ -152,7 +152,7 @@ static const uint32 car_ride_track_pieces_quarter_turn_3_tiles[4][3] = {
|
|||
|
||||
/** rct2: 0x006F72C8 */
|
||||
static void paint_car_ride_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId = car_ride_track_pieces_flat[direction] | session->TrackColours[SCHEME_TRACK];
|
||||
|
||||
|
@ -182,7 +182,7 @@ static void paint_car_ride_track_flat(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x006F72D8 */
|
||||
static void paint_car_ride_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId = car_ride_track_pieces_25_deg_up[direction] | session->TrackColours[SCHEME_TRACK];
|
||||
|
||||
|
@ -219,7 +219,7 @@ static void paint_car_ride_track_25_deg_up(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x006F72E8 */
|
||||
static void paint_car_ride_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId = car_ride_track_pieces_flat_to_25_deg_up[direction] | session->TrackColours[SCHEME_TRACK];
|
||||
|
||||
|
@ -256,7 +256,7 @@ static void paint_car_ride_track_flat_to_25_deg_up(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x006F72F8 */
|
||||
static void paint_car_ride_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId = car_ride_track_pieces_25_deg_up_to_flat[direction] | session->TrackColours[SCHEME_TRACK];
|
||||
|
||||
|
@ -293,28 +293,28 @@ static void paint_car_ride_track_25_deg_up_to_flat(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x006F7308 */
|
||||
static void paint_car_ride_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_car_ride_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_car_ride_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006F7318 */
|
||||
static void paint_car_ride_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_car_ride_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_car_ride_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006F7328 */
|
||||
static void paint_car_ride_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_car_ride_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_car_ride_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006F7338, 0x006F7348, 0x006F7358 */
|
||||
static void paint_car_ride_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
|
||||
|
@ -359,7 +359,7 @@ static void paint_car_ride_station(paint_session * session, uint8 rideIndex, uin
|
|||
metal_a_supports_paint_setup(session, METAL_SUPPORTS_BOXED, 7, 0, height, session->TrackColours[SCHEME_SUPPORTS]);
|
||||
}
|
||||
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -367,7 +367,7 @@ static void paint_car_ride_station(paint_session * session, uint8 rideIndex, uin
|
|||
|
||||
/** rct2: 0x006F7378 */
|
||||
static void paint_car_ride_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
track_paint_util_right_quarter_turn_3_tiles_paint(
|
||||
session, 3, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
|
||||
|
@ -403,15 +403,15 @@ static void paint_car_ride_track_right_quarter_turn_3_tiles(paint_session * sess
|
|||
|
||||
/** rct2: 0x006F7368 */
|
||||
static void paint_car_ride_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
paint_car_ride_track_right_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
|
||||
paint_car_ride_track_right_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006F7388 */
|
||||
static void paint_car_ride_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId = car_ride_track_pieces_left_quarter_turn_1_tile[direction] | session->TrackColours[SCHEME_TRACK];
|
||||
|
||||
|
@ -441,14 +441,14 @@ static void paint_car_ride_track_left_quarter_turn_1_tile(paint_session * sessio
|
|||
|
||||
/** rct2: 0x006F7398 */
|
||||
static void paint_car_ride_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_car_ride_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, mapElement);
|
||||
paint_car_ride_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006F73A8 */
|
||||
static void paint_car_ride_track_spinning_tunnel(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId = car_ride_track_pieces_flat[direction] | session->TrackColours[SCHEME_TRACK];
|
||||
|
||||
|
@ -480,7 +480,7 @@ static void paint_car_ride_track_spinning_tunnel(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x006F73B8 */
|
||||
static void paint_car_ride_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
|
||||
|
@ -530,7 +530,7 @@ static void paint_car_ride_track_60_deg_up(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x006F73C8 */
|
||||
static void paint_car_ride_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
|
||||
|
@ -587,7 +587,7 @@ static void paint_car_ride_track_25_deg_up_to_60_deg_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x006F73D8 */
|
||||
static void paint_car_ride_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
|
||||
|
@ -644,28 +644,28 @@ static void paint_car_ride_track_60_deg_up_to_25_deg_up(paint_session * session,
|
|||
|
||||
/** rct2: 0x006F73E8 */
|
||||
static void paint_car_ride_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_car_ride_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_car_ride_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006F73F8 */
|
||||
static void paint_car_ride_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_car_ride_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_car_ride_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006F7408 */
|
||||
static void paint_car_ride_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_car_ride_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_car_ride_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x006F7418 */
|
||||
static void paint_car_ride_track_log_bumps(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId = car_ride_track_pieces_log_bumps[direction] | session->TrackColours[SCHEME_TRACK];
|
||||
|
||||
|
|
|
@ -25,7 +25,7 @@
|
|||
*/
|
||||
static void paint_circus_show_tent(paint_session * session, uint8 rideIndex, uint8 direction, sint8 al, sint8 cl, uint16 height)
|
||||
{
|
||||
rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
|
||||
|
@ -48,14 +48,14 @@ static void paint_circus_show_tent(paint_session * session, uint8 rideIndex, uin
|
|||
sub_98197C(session, imageId | imageColourFlags, al, cl, 24, 24, 47, height + 3, al + 16, cl + 16, height + 3,
|
||||
get_current_rotation());
|
||||
|
||||
session->CurrentlyDrawnItem = savedMapElement;
|
||||
session->CurrentlyDrawnItem = savedTileElement;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
}
|
||||
/**
|
||||
* rct2: 0x0076FAD4
|
||||
*/
|
||||
static void paint_circus_show(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_3x3[direction][trackSequence];
|
||||
|
||||
|
@ -68,7 +68,7 @@ static void paint_circus_show(paint_session * session, uint8 rideIndex, uint8 tr
|
|||
track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
|
||||
get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
|
||||
fenceSpritesRope, get_current_rotation());
|
||||
|
||||
switch (trackSequence)
|
||||
|
|
|
@ -69,7 +69,7 @@ static void paint_crooked_house_structure(paint_session * session, uint8 directi
|
|||
}
|
||||
|
||||
static void paint_crooked_house(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_3x3[direction][trackSequence];
|
||||
|
||||
|
@ -82,7 +82,7 @@ static void paint_crooked_house(paint_session * session, uint8 rideIndex, uint8
|
|||
track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
|
||||
get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
fenceSpritesRope, get_current_rotation());
|
||||
|
||||
switch (trackSequence)
|
||||
|
|
|
@ -44,7 +44,7 @@ static void paint_dodgems_roof(paint_session * session, sint32 height, sint32 of
|
|||
}
|
||||
|
||||
static void paint_dodgems(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
uint8 relativeTrackSequence = track_map_4x4[direction][trackSequence];
|
||||
|
||||
|
@ -57,7 +57,7 @@ static void paint_dodgems(paint_session * session, uint8 rideIndex, uint8 trackS
|
|||
uint32 imageId = SPR_DODGEMS_FLOOR | session->TrackColours[SCHEME_SUPPORTS];
|
||||
sub_98197C(session, imageId, 0, 0, 30, 30, 1, height, 1, 1, height, get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
|
||||
dodgems_fence_sprites, get_current_rotation());
|
||||
|
||||
switch (direction)
|
||||
|
|
|
@ -58,7 +58,7 @@ static void paint_ferris_wheel_structure(paint_session * session, uint8 rideInde
|
|||
{
|
||||
uint32 imageId, baseImageId;
|
||||
|
||||
rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
|
||||
|
@ -130,7 +130,7 @@ static void paint_ferris_wheel_structure(paint_session * session, uint8 rideInde
|
|||
sub_98199C(session, imageId, xOffset, yOffset, boundBox.length_x, boundBox.length_y, 127, height, boundBox.offset_x,
|
||||
boundBox.offset_y, height, get_current_rotation());
|
||||
|
||||
session->CurrentlyDrawnItem = savedMapElement;
|
||||
session->CurrentlyDrawnItem = savedTileElement;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
}
|
||||
|
||||
|
@ -138,7 +138,7 @@ static void paint_ferris_wheel_structure(paint_session * session, uint8 rideInde
|
|||
* rct2: 0x008A8EC4
|
||||
*/
|
||||
static void paint_ferris_wheel(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
uint8 relativeTrackSequence = track_map_1x4[direction][trackSequence];
|
||||
|
||||
|
@ -163,23 +163,23 @@ static void paint_ferris_wheel(paint_session * session, uint8 rideIndex, uint8 t
|
|||
uint32 imageId;
|
||||
uint8 rotation = get_current_rotation();
|
||||
uint32 colourFlags = session->TrackColours[SCHEME_MISC];
|
||||
if (edges & EDGE_NW && track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, rotation))
|
||||
if (edges & EDGE_NW && track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, rotation))
|
||||
{
|
||||
imageId = SPR_FENCE_ROPE_NW | colourFlags;
|
||||
sub_98199C(session, imageId, 0, 0, 32, 1, 7, height, 0, 2, height + 2, rotation);
|
||||
}
|
||||
if (edges & EDGE_NE && track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, rotation))
|
||||
if (edges & EDGE_NE && track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, rotation))
|
||||
{
|
||||
imageId = SPR_FENCE_ROPE_NE | colourFlags;
|
||||
sub_98199C(session, imageId, 0, 0, 1, 32, 7, height, 2, 0, height + 2, rotation);
|
||||
}
|
||||
if (edges & EDGE_SE && track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, rotation))
|
||||
if (edges & EDGE_SE && track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, rotation))
|
||||
{
|
||||
// Bound box is slightly different from track_paint_util_paint_fences
|
||||
imageId = SPR_FENCE_ROPE_SE | colourFlags;
|
||||
sub_98197C(session, imageId, 0, 0, 28, 1, 7, height, 0, 29, height + 3, rotation);
|
||||
}
|
||||
if (edges & EDGE_SW && track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, rotation))
|
||||
if (edges & EDGE_SW && track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, rotation))
|
||||
{
|
||||
imageId = SPR_FENCE_ROPE_SW | colourFlags;
|
||||
sub_98197C(session, imageId, 0, 0, 1, 32, 7, height, 30, 0, height + 2, rotation);
|
||||
|
|
|
@ -40,7 +40,7 @@ static const uint32 flying_saucers_fence_sprites[] = {
|
|||
* rct2: 0x008873D8
|
||||
*/
|
||||
static void paint_flying_saucers(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
uint8 relativeTrackSequence = track_map_4x4[direction][trackSequence];
|
||||
|
||||
|
@ -53,7 +53,7 @@ static void paint_flying_saucers(paint_session * session, uint8 rideIndex, uint8
|
|||
uint32 imageId = SPR_FLYING_SAUCERS_FLOOR | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C(session, imageId, 0, 0, 30, 30, 1, height, 1, 1, height, get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
flying_saucers_fence_sprites, get_current_rotation());
|
||||
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
|
|
|
@ -136,7 +136,7 @@ static const uint32 ghost_train_track_pieces_brakes[4] = {
|
|||
|
||||
/** rct2: 0x00770BEC */
|
||||
static void paint_ghost_train_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
|
||||
|
@ -172,7 +172,7 @@ static void paint_ghost_train_track_flat(paint_session * session, uint8 rideInde
|
|||
|
||||
/** rct2: 0x00770BFC */
|
||||
static void paint_ghost_train_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
|
||||
|
@ -224,7 +224,7 @@ static void paint_ghost_train_track_25_deg_up(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x00770C0C */
|
||||
static void paint_ghost_train_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
|
||||
|
@ -275,7 +275,7 @@ static void paint_ghost_train_track_flat_to_25_deg_up(paint_session * session, u
|
|||
}
|
||||
|
||||
static void paint_ghost_train_track_25_deg_up_to_flat_shared(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
|
||||
|
@ -311,9 +311,9 @@ static void paint_ghost_train_track_25_deg_up_to_flat_shared(paint_session * ses
|
|||
|
||||
/** rct2: 0x00770C1C */
|
||||
static void paint_ghost_train_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_ghost_train_track_25_deg_up_to_flat_shared(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
paint_ghost_train_track_25_deg_up_to_flat_shared(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -334,17 +334,17 @@ static void paint_ghost_train_track_25_deg_up_to_flat(paint_session * session, u
|
|||
|
||||
/** rct2: 0x00770C2C */
|
||||
static void paint_ghost_train_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_ghost_train_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_ghost_train_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00770C3C */
|
||||
static void paint_ghost_train_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_ghost_train_track_25_deg_up_to_flat_shared(session, rideIndex, trackSequence, (direction + 2) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
|
||||
switch ((direction + 2) % 4)
|
||||
{
|
||||
|
@ -365,14 +365,14 @@ static void paint_ghost_train_track_flat_to_25_deg_down(paint_session * session,
|
|||
|
||||
/** rct2: 0x00770C4C */
|
||||
static void paint_ghost_train_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_ghost_train_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_ghost_train_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00770C5C, 0x00770C6C, 0x00770C7C */
|
||||
static void paint_ghost_train_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
|
||||
|
@ -417,7 +417,7 @@ static void paint_ghost_train_station(paint_session * session, uint8 rideIndex,
|
|||
metal_a_supports_paint_setup(session, METAL_SUPPORTS_BOXED, 7, 0, height, session->TrackColours[SCHEME_SUPPORTS]);
|
||||
}
|
||||
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -425,7 +425,7 @@ static void paint_ghost_train_station(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x00770C9C */
|
||||
static void paint_ghost_train_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
track_paint_util_right_quarter_turn_3_tiles_paint(
|
||||
session, 3, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
|
||||
|
@ -461,16 +461,16 @@ static void paint_ghost_train_track_right_quarter_turn_3_tiles(paint_session * s
|
|||
|
||||
/** rct2: 0x00770CAC */
|
||||
static void paint_ghost_train_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
|
||||
paint_ghost_train_track_right_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00770CAC */
|
||||
static void paint_ghost_train_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
track_paint_util_left_quarter_turn_1_tile_paint(session, 3, height, 0, direction, session->TrackColours[SCHEME_TRACK],
|
||||
ghost_train_track_pieces_quarter_turn_1_tile, get_current_rotation());
|
||||
|
@ -483,15 +483,15 @@ static void paint_ghost_train_track_left_quarter_turn_1_tile(paint_session * ses
|
|||
|
||||
/** rct2: 0x00770CBC */
|
||||
static void paint_ghost_train_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_ghost_train_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x00770CCC */
|
||||
static void paint_ghost_train_track_spinning_tunnel(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId = ghost_train_track_pieces_spinning_tunnel_track[direction] | session->TrackColours[SCHEME_TRACK];
|
||||
|
||||
|
@ -523,7 +523,7 @@ static void paint_ghost_train_track_spinning_tunnel(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x00770CDC */
|
||||
static void paint_ghost_train_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
|
||||
|
|
|
@ -38,7 +38,7 @@ static haunted_house_bound_box haunted_house_data[] = { { 6, 0, 42, 24 }, { 0 },
|
|||
static void paint_haunted_house_structure(paint_session * session, uint8 rideIndex, uint8 direction, sint8 xOffset,
|
||||
sint8 yOffset, uint8 part, uint16 height)
|
||||
{
|
||||
rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
|
||||
uint8 frameNum = 0;
|
||||
|
||||
|
@ -83,7 +83,7 @@ static void paint_haunted_house_structure(paint_session * session, uint8 rideInd
|
|||
boundBox.offset_y, height, get_current_rotation());
|
||||
}
|
||||
|
||||
session->CurrentlyDrawnItem = savedMapElement;
|
||||
session->CurrentlyDrawnItem = savedTileElement;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
}
|
||||
|
||||
|
@ -91,7 +91,7 @@ static void paint_haunted_house_structure(paint_session * session, uint8 rideInd
|
|||
* rct2: 0x0076E9B0
|
||||
*/
|
||||
static void paint_haunted_house(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_3x3[direction][trackSequence];
|
||||
|
||||
|
@ -104,7 +104,7 @@ static void paint_haunted_house(paint_session * session, uint8 rideIndex, uint8
|
|||
track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
|
||||
get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
fenceSpritesRope, get_current_rotation());
|
||||
|
||||
switch (trackSequence)
|
||||
|
|
|
@ -52,9 +52,9 @@ enum
|
|||
* rct: 0x004ACF4A
|
||||
*/
|
||||
static void maze_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
uint16 maze_entry = mapElement->properties.track.maze_entry;
|
||||
uint16 maze_entry = tileElement->properties.track.maze_entry;
|
||||
maze_entry = rol16(maze_entry, direction * 4);
|
||||
|
||||
uint32 rotation = get_current_rotation();
|
||||
|
|
|
@ -32,7 +32,7 @@ static const uint16 merry_go_round_breakdown_vibration[] = { 0, 1, 2, 3, 4, 3, 2
|
|||
static void paint_merry_go_round_structure(paint_session * session, uint8 rideIndex, uint8 direction, sint8 xOffset,
|
||||
sint8 yOffset, uint16 height)
|
||||
{
|
||||
rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
height += 7;
|
||||
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
|
@ -106,7 +106,7 @@ static void paint_merry_go_round_structure(paint_session * session, uint8 rideIn
|
|||
}
|
||||
}
|
||||
|
||||
session->CurrentlyDrawnItem = savedMapElement;
|
||||
session->CurrentlyDrawnItem = savedTileElement;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
}
|
||||
|
||||
|
@ -114,7 +114,7 @@ static void paint_merry_go_round_structure(paint_session * session, uint8 rideIn
|
|||
* rct2: 0x00761B0C
|
||||
*/
|
||||
static void paint_merry_go_round(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_3x3[direction][trackSequence];
|
||||
|
||||
|
@ -127,7 +127,7 @@ static void paint_merry_go_round(paint_session * session, uint8 rideIndex, uint8
|
|||
track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
|
||||
get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
fenceSpritesRope, get_current_rotation());
|
||||
|
||||
switch (trackSequence)
|
||||
|
|
|
@ -390,7 +390,7 @@ static paint_struct * mini_golf_paint_util_7c(paint_session * session, uint8 dir
|
|||
z_offset, bound_box_offset_x, bound_box_offset_y, bound_box_offset_z, rotation);
|
||||
}
|
||||
|
||||
static bool mini_golf_paint_util_should_draw_fence(paint_session * session, rct_tile_element * mapElement)
|
||||
static bool mini_golf_paint_util_should_draw_fence(paint_session * session, rct_tile_element * tileElement)
|
||||
{
|
||||
if (!session->DidPassSurface)
|
||||
{
|
||||
|
@ -399,7 +399,7 @@ static bool mini_golf_paint_util_should_draw_fence(paint_session * session, rct_
|
|||
}
|
||||
|
||||
rct_tile_element * surfaceElement = session->SurfaceElement;
|
||||
if (surfaceElement->base_height != mapElement->base_height)
|
||||
if (surfaceElement->base_height != tileElement->base_height)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
@ -414,7 +414,7 @@ static bool mini_golf_paint_util_should_draw_fence(paint_session * session, rct_
|
|||
|
||||
/** rct2: 0x0087F10C */
|
||||
static void paint_mini_golf_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
|
||||
|
@ -435,7 +435,7 @@ static void paint_mini_golf_track_flat(paint_session * session, uint8 rideIndex,
|
|||
paint_util_set_segment_support_height(session, paint_util_rotate_segments(SEGMENT_D0 | SEGMENT_C4 | SEGMENT_CC, direction),
|
||||
0xFFFF, 0);
|
||||
|
||||
if (mini_golf_paint_util_should_draw_fence(session, mapElement))
|
||||
if (mini_golf_paint_util_should_draw_fence(session, tileElement))
|
||||
{
|
||||
if (direction & 1)
|
||||
{
|
||||
|
@ -460,7 +460,7 @@ static void paint_mini_golf_track_flat(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x0087F11C */
|
||||
static void paint_mini_golf_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
|
||||
|
@ -498,7 +498,7 @@ static void paint_mini_golf_track_25_deg_up(paint_session * session, uint8 rideI
|
|||
|
||||
/** rct2: 0x0087F12C */
|
||||
static void paint_mini_golf_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
|
||||
|
@ -536,7 +536,7 @@ static void paint_mini_golf_track_flat_to_25_deg_up(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x0087F13C */
|
||||
static void paint_mini_golf_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
|
||||
|
@ -574,28 +574,28 @@ static void paint_mini_golf_track_25_deg_up_to_flat(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x0087F14C */
|
||||
static void paint_mini_golf_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_mini_golf_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_mini_golf_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0087F15C */
|
||||
static void paint_mini_golf_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_mini_golf_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_mini_golf_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0087F16C */
|
||||
static void paint_mini_golf_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_mini_golf_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_mini_golf_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0087F17C, 0x0087F18C, 0x0087F19C */
|
||||
static void paint_mini_golf_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
|
@ -608,14 +608,14 @@ static void paint_mini_golf_station(paint_session * session, uint8 rideIndex, ui
|
|||
|
||||
if (direction & 1)
|
||||
{
|
||||
hasFence = track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, get_current_rotation());
|
||||
hasFence = track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, get_current_rotation());
|
||||
if (hasFence)
|
||||
{
|
||||
imageId = SPR_MINI_GOLF_FLAT_FENCE_BACK_NW_SE | session->TrackColours[SCHEME_MISC];
|
||||
sub_98197C(session, imageId, -10, 0, 1, 32, 7, height, 0, 0, height + 2, get_current_rotation());
|
||||
}
|
||||
|
||||
bool hasSWFence = track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation());
|
||||
bool hasSWFence = track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation());
|
||||
if (hasFence)
|
||||
{
|
||||
imageId = SPR_MINI_GOLF_FLAT_FENCE_FRONT_NW_SE | session->TrackColours[SCHEME_MISC];
|
||||
|
@ -630,14 +630,14 @@ static void paint_mini_golf_station(paint_session * session, uint8 rideIndex, ui
|
|||
}
|
||||
else
|
||||
{
|
||||
hasFence = track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, get_current_rotation());
|
||||
hasFence = track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, get_current_rotation());
|
||||
if (hasFence)
|
||||
{
|
||||
imageId = SPR_MINI_GOLF_FLAT_FENCE_BACK_SW_NE | session->TrackColours[SCHEME_MISC];
|
||||
sub_98197C(session, imageId, 0, -10, 32, 1, 7, height, 0, 0, height + 2, get_current_rotation());
|
||||
}
|
||||
|
||||
bool hasSEFence = track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation());
|
||||
bool hasSEFence = track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation());
|
||||
if (hasFence)
|
||||
{
|
||||
imageId = SPR_MINI_GOLF_FLAT_FENCE_FRONT_SW_NE | session->TrackColours[SCHEME_MISC];
|
||||
|
@ -658,7 +658,7 @@ static void paint_mini_golf_station(paint_session * session, uint8 rideIndex, ui
|
|||
|
||||
/** rct2: 0x0087F1AC */
|
||||
static void paint_mini_golf_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
|
||||
|
@ -670,7 +670,7 @@ static void paint_mini_golf_track_left_quarter_turn_1_tile(paint_session * sessi
|
|||
paint_util_set_segment_support_height(
|
||||
session, paint_util_rotate_segments(SEGMENT_B8 | SEGMENT_C8 | SEGMENT_C4 | SEGMENT_D0, direction), 0xFFFF, 0);
|
||||
|
||||
const bool shouldDrawFence = mini_golf_paint_util_should_draw_fence(session, mapElement);
|
||||
const bool shouldDrawFence = mini_golf_paint_util_should_draw_fence(session, tileElement);
|
||||
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -737,9 +737,9 @@ static void paint_mini_golf_track_left_quarter_turn_1_tile(paint_session * sessi
|
|||
|
||||
/** rct2: 0x0087F1BC */
|
||||
static void paint_mini_golf_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_mini_golf_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, mapElement);
|
||||
paint_mini_golf_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
static void paint_mini_golf_hole_ab(paint_session * session, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
|
@ -798,21 +798,21 @@ static void paint_mini_golf_hole_ab(paint_session * session, uint8 trackSequence
|
|||
|
||||
/** rct2: 0x0087F1CC */
|
||||
static void paint_mini_golf_hole_a(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_mini_golf_hole_ab(session, trackSequence, direction, height, mini_golf_track_sprites_hole_a);
|
||||
}
|
||||
|
||||
/** rct2: 0x0087F1DC */
|
||||
static void paint_mini_golf_hole_b(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_mini_golf_hole_ab(session, trackSequence, direction, height, mini_golf_track_sprites_hole_b);
|
||||
}
|
||||
|
||||
/** rct2: 0x0087F1EC */
|
||||
static void paint_mini_golf_hole_c(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
LocationXY16 boundBox, boundBoxOffset;
|
||||
|
@ -881,7 +881,7 @@ static void paint_mini_golf_hole_c(paint_session * session, uint8 rideIndex, uin
|
|||
|
||||
/** rct2: 0x0087F1FC */
|
||||
static void paint_mini_golf_hole_d(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
LocationXY16 boundBox, boundBoxOffset;
|
||||
|
@ -973,7 +973,7 @@ static void paint_mini_golf_hole_d(paint_session * session, uint8 rideIndex, uin
|
|||
|
||||
/** rct2: 0x0087F1FC */
|
||||
static void paint_mini_golf_hole_e(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
LocationXY16 boundBox, boundBoxOffset;
|
||||
|
|
|
@ -25,7 +25,7 @@
|
|||
|
||||
/** rct2: 0x */
|
||||
static void paint_mini_helicopters_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
|
||||
|
@ -54,7 +54,7 @@ static void paint_mini_helicopters_track_station(paint_session * session, uint8
|
|||
paint_util_push_tunnel_right(session, height, TUNNEL_6);
|
||||
}
|
||||
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -62,7 +62,7 @@ static void paint_mini_helicopters_track_station(paint_session * session, uint8
|
|||
|
||||
/** rct2: 0x0081F348 */
|
||||
static void paint_mini_helicopters_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
uint32 imageId;
|
||||
|
@ -93,7 +93,7 @@ static void paint_mini_helicopters_track_flat(paint_session * session, uint8 rid
|
|||
|
||||
/** rct2: 0x0081F368 */
|
||||
static void paint_mini_helicopters_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
uint32 imageId;
|
||||
|
@ -134,7 +134,7 @@ static void paint_mini_helicopters_track_flat_to_25_deg_up(paint_session * sessi
|
|||
|
||||
/** rct2: 0x0081F358 */
|
||||
static void paint_mini_helicopters_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
uint32 imageId;
|
||||
|
@ -175,7 +175,7 @@ static void paint_mini_helicopters_track_25_deg_up(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x0081F378 */
|
||||
static void paint_mini_helicopters_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
uint32 imageId;
|
||||
|
@ -216,29 +216,29 @@ static void paint_mini_helicopters_track_25_deg_up_to_flat(paint_session * sessi
|
|||
|
||||
/** rct2: 0x */
|
||||
static void paint_mini_helicopters_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_mini_helicopters_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_mini_helicopters_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0081F388 */
|
||||
static void paint_mini_helicopters_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_mini_helicopters_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_mini_helicopters_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0081F3A8 */
|
||||
static void paint_mini_helicopters_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_mini_helicopters_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_mini_helicopters_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0081F3E8 */
|
||||
static void paint_mini_helicopters_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
track_paint_util_left_quarter_turn_3_tiles_paint(
|
||||
session, 3, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
|
||||
|
@ -271,16 +271,16 @@ static const uint8 mini_helicopters_right_quarter_turn_3_tiles_to_left_turn_map[
|
|||
/** rct2: 0x0081F3F8 */
|
||||
static void paint_mini_helicopters_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mini_helicopters_right_quarter_turn_3_tiles_to_left_turn_map[trackSequence];
|
||||
paint_mini_helicopters_track_left_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 3) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0081F408 */
|
||||
static void paint_mini_helicopters_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
track_paint_util_left_quarter_turn_1_tile_paint(session, 1, height, 0, direction, session->TrackColours[SCHEME_TRACK],
|
||||
trackSpritesSubmarineRideMiniHelicoptersQuarterTurn1Tile,
|
||||
|
@ -295,10 +295,10 @@ static void paint_mini_helicopters_track_left_quarter_turn_1_tile(paint_session
|
|||
/** rct2: 0x0081F418 */
|
||||
static void paint_mini_helicopters_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
paint_mini_helicopters_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -164,7 +164,7 @@ static paint_struct * paint_monorail_cycles_util_7c(paint_session * session, boo
|
|||
|
||||
/** rct2: 0x0088AD48 */
|
||||
static void paint_monorail_cycles_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId = monorail_cycles_track_pieces_flat[(direction & 1)] | session->TrackColours[SCHEME_TRACK];
|
||||
paint_monorail_cycles_util_7c(session, (bool)(direction & 1), imageId, 0, 0, 32, 20, 3, height, 0, 6, height,
|
||||
|
@ -189,7 +189,7 @@ static void paint_monorail_cycles_track_flat(paint_session * session, uint8 ride
|
|||
|
||||
/** rct2: 0x0088ADD8 */
|
||||
static void paint_monorail_cycles_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
|
||||
|
@ -218,7 +218,7 @@ static void paint_monorail_cycles_station(paint_session * session, uint8 rideInd
|
|||
paint_util_push_tunnel_right(session, height, TUNNEL_6);
|
||||
}
|
||||
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
|
||||
paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
|
||||
paint_util_set_general_support_height(session, height + 32, 0x20);
|
||||
|
@ -226,7 +226,7 @@ static void paint_monorail_cycles_station(paint_session * session, uint8 rideInd
|
|||
|
||||
/** rct2: 0x0088AD88 */
|
||||
static void paint_monorail_cycles_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
track_paint_util_left_quarter_turn_3_tiles_paint(
|
||||
session, 3, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
|
||||
|
@ -259,11 +259,11 @@ static const uint8 monorail_cycles_right_quarter_turn_3_tiles_to_left_turn_map[]
|
|||
/** rct2: 0x0088AD98 */
|
||||
static void paint_monorail_cycles_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = monorail_cycles_right_quarter_turn_3_tiles_to_left_turn_map[trackSequence];
|
||||
paint_monorail_cycles_track_left_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 3) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
static const sint8 monorail_cycles_track_right_quarter_turn_5_tiles_support_height_offset[][7] = {
|
||||
|
@ -283,7 +283,7 @@ static const sint8 monorail_cycles_track_right_quarter_turn_5_tiles_support_spec
|
|||
/** rct2: 0x0088ADB8 */
|
||||
static void paint_monorail_cycles_track_right_quarter_turn_5_tiles(paint_session * session, uint8 rideIndex,
|
||||
uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
track_paint_util_right_quarter_turn_5_tiles_paint(
|
||||
session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
|
||||
|
@ -386,16 +386,16 @@ static void paint_monorail_cycles_track_right_quarter_turn_5_tiles(paint_session
|
|||
|
||||
/** rct2: 0x0088ADA8 */
|
||||
static void paint_monorail_cycles_track_left_quarter_turn_5_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
|
||||
paint_monorail_cycles_track_right_quarter_turn_5_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height,
|
||||
mapElement);
|
||||
tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0088ADC8 */
|
||||
static void paint_monorail_cycles_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (direction == 2 || direction == 3)
|
||||
{
|
||||
|
@ -498,7 +498,7 @@ static void paint_monorail_cycles_track_s_bend_left(paint_session * session, uin
|
|||
|
||||
/** rct2: 0x*/
|
||||
static void paint_monorail_cycles_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (direction == 2 || direction == 3)
|
||||
{
|
||||
|
|
|
@ -81,7 +81,7 @@ void vehicle_visual_observation_tower(paint_session * session, sint32 x, sint32
|
|||
|
||||
/** rct2: 0x0070DD6C */
|
||||
static void paint_observation_tower_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_3x3[direction][trackSequence];
|
||||
|
||||
|
@ -94,7 +94,7 @@ static void paint_observation_tower_base(paint_session * session, uint8 rideInde
|
|||
uint32 imageId = SPR_FLOOR_METAL_B | session->TrackColours[SCHEME_SUPPORTS];
|
||||
sub_98197C(session, imageId, 0, 0, 32, 32, 1, height, 0, 0, height, get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
fenceSpritesMetalB, get_current_rotation());
|
||||
|
||||
if (trackSequence == 0)
|
||||
|
@ -157,7 +157,7 @@ static void paint_observation_tower_base(paint_session * session, uint8 rideInde
|
|||
|
||||
/** rct2: 0x0070DD7C */
|
||||
static void paint_observation_tower_section(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (trackSequence == 1)
|
||||
{
|
||||
|
@ -167,8 +167,8 @@ static void paint_observation_tower_section(paint_session * session, uint8 rideI
|
|||
uint32 imageId = SPR_OBSERVATION_TOWER_SEGMENT | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
|
||||
|
||||
rct_tile_element * nextMapElement = mapElement + 1;
|
||||
if (tile_element_is_last_for_tile(mapElement) || mapElement->clearance_height != nextMapElement->base_height)
|
||||
rct_tile_element * nextTileElement = tileElement + 1;
|
||||
if (tile_element_is_last_for_tile(tileElement) || tileElement->clearance_height != nextTileElement->base_height)
|
||||
{
|
||||
imageId = SPR_OBSERVATION_TOWER_SEGMENT_TOP | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98199C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
|
||||
|
|
|
@ -39,7 +39,7 @@ static const uint32 space_rings_fence_sprites[] = {
|
|||
/** rct2: 0x00768A3B */
|
||||
static void paint_space_rings_structure(paint_session * session, Ride * ride, uint8 direction, uint32 segment, sint32 height)
|
||||
{
|
||||
rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
|
||||
uint32 vehicleIndex = (segment - direction) & 0x3;
|
||||
|
||||
|
@ -84,13 +84,13 @@ static void paint_space_rings_structure(paint_session * session, Ride * ride, ui
|
|||
}
|
||||
}
|
||||
|
||||
session->CurrentlyDrawnItem = savedMapElement;
|
||||
session->CurrentlyDrawnItem = savedTileElement;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
}
|
||||
|
||||
/** rct2: 0x00767C40 */
|
||||
static void paint_space_rings(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_3x3[direction][trackSequence];
|
||||
|
||||
|
@ -108,19 +108,19 @@ static void paint_space_rings(paint_session * session, uint8 rideIndex, uint8 tr
|
|||
switch (trackSequence)
|
||||
{
|
||||
case 7:
|
||||
if (track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation()))
|
||||
if (track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation()))
|
||||
{
|
||||
imageId = SPR_SPACE_RINGS_FENCE_SW | session->TrackColours[SCHEME_MISC];
|
||||
sub_98197C(session, imageId, 0, 0, 1, 28, 7, height, 29, 0, height + 2, get_current_rotation());
|
||||
}
|
||||
if (track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation()))
|
||||
if (track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation()))
|
||||
{
|
||||
imageId = SPR_SPACE_RINGS_FENCE_SE | session->TrackColours[SCHEME_MISC];
|
||||
sub_98197C(session, imageId, 0, 0, 28, 1, 7, height, 0, 29, height + 2, get_current_rotation());
|
||||
}
|
||||
break;
|
||||
default:
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
space_rings_fence_sprites, get_current_rotation());
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -53,7 +53,7 @@ enum
|
|||
};
|
||||
|
||||
static void spiral_slide_paint_tile_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 image_id = 0;
|
||||
|
||||
|
@ -70,7 +70,7 @@ static void spiral_slide_paint_tile_right(paint_session * session, uint8 rideInd
|
|||
}
|
||||
|
||||
static void spiral_slide_paint_tile_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 image_id = 0;
|
||||
|
||||
|
@ -87,7 +87,7 @@ static void spiral_slide_paint_tile_left(paint_session * session, uint8 rideInde
|
|||
}
|
||||
|
||||
static void spiral_slide_paint_tile_front(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 image_id = 0;
|
||||
|
||||
|
@ -194,7 +194,7 @@ static const uint32 spiral_slide_fence_sprites[] = {
|
|||
* rct: 0x007485C8
|
||||
*/
|
||||
static void paint_spiral_slide(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_2x2[direction][trackSequence];
|
||||
|
||||
|
@ -208,19 +208,19 @@ static void paint_spiral_slide(paint_session * session, uint8 rideIndex, uint8 t
|
|||
uint32 imageId = ((direction & 1) ? SPIRAL_SLIDE_BASE_B : SPIRAL_SLIDE_BASE_A) | session->TrackColours[SCHEME_SUPPORTS];
|
||||
sub_98197C(session, imageId, 0, 0, 32, 32, 1, height, 0, 0, height, get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
spiral_slide_fence_sprites, get_current_rotation());
|
||||
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 1:
|
||||
spiral_slide_paint_tile_right(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
spiral_slide_paint_tile_right(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
break;
|
||||
case 2:
|
||||
spiral_slide_paint_tile_left(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
spiral_slide_paint_tile_left(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
break;
|
||||
case 3:
|
||||
spiral_slide_paint_tile_front(session, rideIndex, trackSequence, direction, height, mapElement);
|
||||
spiral_slide_paint_tile_front(session, rideIndex, trackSequence, direction, height, tileElement);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1067,7 +1067,7 @@ sint32 ride_is_valid_for_test(sint32 rideIndex, sint32 goingToBeOpen, sint32 isA
|
|||
sint32 ride_initialise_construction_window(sint32 rideIndex);
|
||||
void ride_construction_invalidate_current_track();
|
||||
sint32 sub_6C683D(sint32* x, sint32* y, sint32* z, sint32 direction, sint32 type, uint16 extra_params, rct_tile_element** output_element, uint16 flags);
|
||||
void ride_set_map_tooltip(rct_tile_element *mapElement);
|
||||
void ride_set_map_tooltip(rct_tile_element *tileElement);
|
||||
sint32 ride_music_params_update(sint16 x, sint16 y, sint16 z, uint8 rideIndex, uint16 sampleRate, uint32 position, uint8 *tuneId);
|
||||
void ride_music_update_final();
|
||||
void ride_prepare_breakdown(sint32 rideIndex, sint32 breakdownReason);
|
||||
|
@ -1137,7 +1137,7 @@ void ride_construction_set_default_next_piece();
|
|||
bool track_block_get_next(rct_xy_element *input, rct_xy_element *output, sint32 *z, sint32 *direction);
|
||||
bool track_block_get_next_from_zero(sint16 x, sint16 y, sint16 z_start, uint8 rideIndex, uint8 direction_start, rct_xy_element *output, sint32 *z, sint32 *direction);
|
||||
|
||||
bool track_block_get_previous(sint32 x, sint32 y, rct_tile_element *mapElement, track_begin_end *outTrackBeginEnd);
|
||||
bool track_block_get_previous(sint32 x, sint32 y, rct_tile_element *tileElement, track_begin_end *outTrackBeginEnd);
|
||||
bool track_block_get_previous_from_zero(sint16 x, sint16 y, sint16 z, uint8 rideIndex, uint8 direction, track_begin_end *outTrackBeginEnd);
|
||||
|
||||
void window_ride_construction_update_active_elements();
|
||||
|
|
|
@ -80,7 +80,7 @@ static void ride_ratings_update_state_5();
|
|||
static void ride_ratings_begin_proximity_loop();
|
||||
static void ride_ratings_calculate(Ride *ride);
|
||||
static void ride_ratings_calculate_value(Ride *ride);
|
||||
static void ride_ratings_score_close_proximity(rct_tile_element *mapElement);
|
||||
static void ride_ratings_score_close_proximity(rct_tile_element *tileElement);
|
||||
|
||||
static void ride_ratings_add(rating_tuple * rating, sint32 excitement, sint32 intensity, sint32 nausea);
|
||||
|
||||
|
@ -193,31 +193,31 @@ static void ride_ratings_update_state_2()
|
|||
sint32 z = gRideRatingsCalcData.proximity_z / 8;
|
||||
sint32 trackType = gRideRatingsCalcData.proximity_track_type;
|
||||
|
||||
rct_tile_element *mapElement = map_get_first_element_at(x, y);
|
||||
rct_tile_element *tileElement = map_get_first_element_at(x, y);
|
||||
do {
|
||||
if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
continue;
|
||||
if (mapElement->base_height != z)
|
||||
if (tileElement->base_height != z)
|
||||
continue;
|
||||
|
||||
if (
|
||||
trackType == 255 ||
|
||||
(tile_element_get_track_sequence(mapElement) == 0 && trackType == mapElement->properties.track.type))
|
||||
(tile_element_get_track_sequence(tileElement) == 0 && trackType == tileElement->properties.track.type))
|
||||
{
|
||||
if (trackType == TRACK_ELEM_END_STATION) {
|
||||
sint32 entranceIndex = tile_element_get_station(mapElement);
|
||||
sint32 entranceIndex = tile_element_get_station(tileElement);
|
||||
gRideRatingsCalcData.station_flags &= ~RIDE_RATING_STATION_FLAG_NO_ENTRANCE;
|
||||
if (ride->entrances[entranceIndex].xy == RCT_XY8_UNDEFINED) {
|
||||
gRideRatingsCalcData.station_flags |= RIDE_RATING_STATION_FLAG_NO_ENTRANCE;
|
||||
}
|
||||
}
|
||||
|
||||
ride_ratings_score_close_proximity(mapElement);
|
||||
ride_ratings_score_close_proximity(tileElement);
|
||||
|
||||
rct_xy_element trackElement = {
|
||||
.x = gRideRatingsCalcData.proximity_x,
|
||||
.y = gRideRatingsCalcData.proximity_y,
|
||||
.element = mapElement
|
||||
.element = tileElement
|
||||
};
|
||||
rct_xy_element nextTrackElement;
|
||||
if (!track_block_get_next(&trackElement, &nextTrackElement, NULL, NULL)) {
|
||||
|
@ -228,7 +228,7 @@ static void ride_ratings_update_state_2()
|
|||
x = nextTrackElement.x;
|
||||
y = nextTrackElement.y;
|
||||
z = nextTrackElement.element->base_height * 8;
|
||||
mapElement = nextTrackElement.element;
|
||||
tileElement = nextTrackElement.element;
|
||||
if (x == gRideRatingsCalcData.proximity_start_x && y == gRideRatingsCalcData.proximity_start_y && z == gRideRatingsCalcData.proximity_start_z) {
|
||||
gRideRatingsCalcData.state = RIDE_RATINGS_STATE_CALCULATE;
|
||||
return;
|
||||
|
@ -236,10 +236,10 @@ static void ride_ratings_update_state_2()
|
|||
gRideRatingsCalcData.proximity_x = x;
|
||||
gRideRatingsCalcData.proximity_y = y;
|
||||
gRideRatingsCalcData.proximity_z = z;
|
||||
gRideRatingsCalcData.proximity_track_type = mapElement->properties.track.type;
|
||||
gRideRatingsCalcData.proximity_track_type = tileElement->properties.track.type;
|
||||
return;
|
||||
}
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
gRideRatingsCalcData.state = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
|
||||
}
|
||||
|
@ -290,20 +290,20 @@ static void ride_ratings_update_state_5()
|
|||
sint32 z = gRideRatingsCalcData.proximity_z / 8;
|
||||
sint32 trackType = gRideRatingsCalcData.proximity_track_type;
|
||||
|
||||
rct_tile_element *mapElement = map_get_first_element_at(x, y);
|
||||
rct_tile_element *tileElement = map_get_first_element_at(x, y);
|
||||
do {
|
||||
if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
|
||||
continue;
|
||||
if (mapElement->base_height != z)
|
||||
if (tileElement->base_height != z)
|
||||
continue;
|
||||
|
||||
if (trackType == 255 || trackType == mapElement->properties.track.type) {
|
||||
ride_ratings_score_close_proximity(mapElement);
|
||||
if (trackType == 255 || trackType == tileElement->properties.track.type) {
|
||||
ride_ratings_score_close_proximity(tileElement);
|
||||
|
||||
x = gRideRatingsCalcData.proximity_x;
|
||||
y = gRideRatingsCalcData.proximity_y;
|
||||
track_begin_end trackBeginEnd;
|
||||
if (!track_block_get_previous(x, y, mapElement, &trackBeginEnd)) {
|
||||
if (!track_block_get_previous(x, y, tileElement, &trackBeginEnd)) {
|
||||
gRideRatingsCalcData.state = RIDE_RATINGS_STATE_CALCULATE;
|
||||
return;
|
||||
}
|
||||
|
@ -321,7 +321,7 @@ static void ride_ratings_update_state_5()
|
|||
gRideRatingsCalcData.proximity_track_type = trackBeginEnd.begin_element->properties.track.type;
|
||||
return;
|
||||
}
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
gRideRatingsCalcData.state = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
|
||||
}
|
||||
|
@ -377,39 +377,39 @@ static void proximity_score_increment(sint32 type)
|
|||
*
|
||||
* rct2: 0x006B6207
|
||||
*/
|
||||
static void ride_ratings_score_close_proximity_in_direction(rct_tile_element *inputMapElement, sint32 direction)
|
||||
static void ride_ratings_score_close_proximity_in_direction(rct_tile_element *inputTileElement, sint32 direction)
|
||||
{
|
||||
sint32 x = gRideRatingsCalcData.proximity_x + TileDirectionDelta[direction].x;
|
||||
sint32 y = gRideRatingsCalcData.proximity_y + TileDirectionDelta[direction].y;
|
||||
if (x < 0 || y < 0 || x >= (32 * 256) || y >= (32 * 256))
|
||||
return;
|
||||
|
||||
rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
do {
|
||||
switch (tile_element_get_type(mapElement)) {
|
||||
switch (tile_element_get_type(tileElement)) {
|
||||
case TILE_ELEMENT_TYPE_SURFACE:
|
||||
if (gRideRatingsCalcData.proximity_base_height <= inputMapElement->base_height) {
|
||||
if (inputMapElement->clearance_height <= mapElement->base_height) {
|
||||
if (gRideRatingsCalcData.proximity_base_height <= inputTileElement->base_height) {
|
||||
if (inputTileElement->clearance_height <= tileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_SURFACE_SIDE_CLOSE);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case TILE_ELEMENT_TYPE_PATH:
|
||||
if (abs((sint32)inputMapElement->base_height - (sint32)mapElement->base_height) <= 2) {
|
||||
if (abs((sint32)inputTileElement->base_height - (sint32)tileElement->base_height) <= 2) {
|
||||
proximity_score_increment(PROXIMITY_PATH_SIDE_CLOSE);
|
||||
}
|
||||
break;
|
||||
case TILE_ELEMENT_TYPE_TRACK:
|
||||
if (inputMapElement->properties.track.ride_index != mapElement->properties.track.ride_index) {
|
||||
if (abs((sint32)inputMapElement->base_height - (sint32)mapElement->base_height) <= 2) {
|
||||
if (inputTileElement->properties.track.ride_index != tileElement->properties.track.ride_index) {
|
||||
if (abs((sint32)inputTileElement->base_height - (sint32)tileElement->base_height) <= 2) {
|
||||
proximity_score_increment(PROXIMITY_FOREIGN_TRACK_SIDE_CLOSE);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case TILE_ELEMENT_TYPE_SCENERY:
|
||||
case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
|
||||
if (mapElement->base_height < inputMapElement->clearance_height) {
|
||||
if (inputMapElement->base_height > mapElement->clearance_height) {
|
||||
if (tileElement->base_height < inputTileElement->clearance_height) {
|
||||
if (inputTileElement->base_height > tileElement->clearance_height) {
|
||||
proximity_score_increment(PROXIMITY_SCENERY_SIDE_ABOVE);
|
||||
} else {
|
||||
proximity_score_increment(PROXIMITY_SCENERY_SIDE_BELOW);
|
||||
|
@ -417,18 +417,18 @@ static void ride_ratings_score_close_proximity_in_direction(rct_tile_element *in
|
|||
}
|
||||
break;
|
||||
}
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
}
|
||||
|
||||
static void ride_ratings_score_close_proximity_loops_helper(rct_tile_element *inputMapElement, sint32 x, sint32 y)
|
||||
static void ride_ratings_score_close_proximity_loops_helper(rct_tile_element *inputTileElement, sint32 x, sint32 y)
|
||||
{
|
||||
rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
do {
|
||||
switch (tile_element_get_type(mapElement)) {
|
||||
switch (tile_element_get_type(tileElement)) {
|
||||
case TILE_ELEMENT_TYPE_PATH:
|
||||
{
|
||||
sint32 zDiff = (sint32)mapElement->base_height - (sint32)inputMapElement->base_height;
|
||||
sint32 zDiff = (sint32)tileElement->base_height - (sint32)inputTileElement->base_height;
|
||||
if (zDiff >= 0 && zDiff <= 16)
|
||||
{
|
||||
proximity_score_increment(PROXIMITY_PATH_TROUGH_VERTICAL_LOOP);
|
||||
|
@ -437,16 +437,16 @@ static void ride_ratings_score_close_proximity_loops_helper(rct_tile_element *in
|
|||
|
||||
case TILE_ELEMENT_TYPE_TRACK:
|
||||
{
|
||||
sint32 unk = (mapElement->type ^ inputMapElement->type) & 1;
|
||||
sint32 unk = (tileElement->type ^ inputTileElement->type) & 1;
|
||||
if (unk != 0)
|
||||
{
|
||||
sint32 zDiff = (sint32)mapElement->base_height - (sint32)inputMapElement->base_height;
|
||||
sint32 zDiff = (sint32)tileElement->base_height - (sint32)inputTileElement->base_height;
|
||||
if (zDiff >= 0 && zDiff <= 16)
|
||||
{
|
||||
proximity_score_increment(PROXIMITY_TRACK_THROUGH_VERTICAL_LOOP);
|
||||
if (
|
||||
mapElement->properties.track.type == TRACK_ELEM_LEFT_VERTICAL_LOOP ||
|
||||
mapElement->properties.track.type == TRACK_ELEM_RIGHT_VERTICAL_LOOP
|
||||
tileElement->properties.track.type == TRACK_ELEM_LEFT_VERTICAL_LOOP ||
|
||||
tileElement->properties.track.type == TRACK_ELEM_RIGHT_VERTICAL_LOOP
|
||||
)
|
||||
{
|
||||
proximity_score_increment(PROXIMITY_INTERSECTING_VERTICAL_LOOP);
|
||||
|
@ -455,25 +455,25 @@ static void ride_ratings_score_close_proximity_loops_helper(rct_tile_element *in
|
|||
}
|
||||
} break;
|
||||
}
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* rct2: 0x006B62DA
|
||||
*/
|
||||
static void ride_ratings_score_close_proximity_loops(rct_tile_element *inputMapElement)
|
||||
static void ride_ratings_score_close_proximity_loops(rct_tile_element *inputTileElement)
|
||||
{
|
||||
sint32 trackType = inputMapElement->properties.track.type;
|
||||
sint32 trackType = inputTileElement->properties.track.type;
|
||||
if (trackType == TRACK_ELEM_LEFT_VERTICAL_LOOP || trackType == TRACK_ELEM_RIGHT_VERTICAL_LOOP) {
|
||||
sint32 x = gRideRatingsCalcData.proximity_x;
|
||||
sint32 y = gRideRatingsCalcData.proximity_y;
|
||||
ride_ratings_score_close_proximity_loops_helper(inputMapElement, x, y);
|
||||
ride_ratings_score_close_proximity_loops_helper(inputTileElement, x, y);
|
||||
|
||||
sint32 direction = tile_element_get_direction(inputMapElement);
|
||||
sint32 direction = tile_element_get_direction(inputTileElement);
|
||||
x = gRideRatingsCalcData.proximity_x + TileDirectionDelta[direction].x;
|
||||
y = gRideRatingsCalcData.proximity_y + TileDirectionDelta[direction].y;
|
||||
ride_ratings_score_close_proximity_loops_helper(inputMapElement, x, y);
|
||||
ride_ratings_score_close_proximity_loops_helper(inputTileElement, x, y);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -481,7 +481,7 @@ static void ride_ratings_score_close_proximity_loops(rct_tile_element *inputMapE
|
|||
*
|
||||
* rct2: 0x006B5F9D
|
||||
*/
|
||||
static void ride_ratings_score_close_proximity(rct_tile_element *inputMapElement)
|
||||
static void ride_ratings_score_close_proximity(rct_tile_element *inputTileElement)
|
||||
{
|
||||
if (gRideRatingsCalcData.station_flags & RIDE_RATING_STATION_FLAG_NO_ENTRANCE) {
|
||||
return;
|
||||
|
@ -490,15 +490,15 @@ static void ride_ratings_score_close_proximity(rct_tile_element *inputMapElement
|
|||
gRideRatingsCalcData.proximity_total++;
|
||||
sint32 x = gRideRatingsCalcData.proximity_x;
|
||||
sint32 y = gRideRatingsCalcData.proximity_y;
|
||||
rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
|
||||
do {
|
||||
switch (tile_element_get_type(mapElement)) {
|
||||
switch (tile_element_get_type(tileElement)) {
|
||||
case TILE_ELEMENT_TYPE_SURFACE:
|
||||
gRideRatingsCalcData.proximity_base_height = mapElement->base_height;
|
||||
if (mapElement->base_height * 8 == gRideRatingsCalcData.proximity_z) {
|
||||
gRideRatingsCalcData.proximity_base_height = tileElement->base_height;
|
||||
if (tileElement->base_height * 8 == gRideRatingsCalcData.proximity_z) {
|
||||
proximity_score_increment(PROXIMITY_SURFACE_TOUCH);
|
||||
}
|
||||
sint32 waterHeight = map_get_water_height(mapElement);
|
||||
sint32 waterHeight = map_get_water_height(tileElement);
|
||||
if (waterHeight != 0) {
|
||||
sint32 z = waterHeight * 16;
|
||||
if (z <= gRideRatingsCalcData.proximity_z) {
|
||||
|
@ -518,69 +518,69 @@ static void ride_ratings_score_close_proximity(rct_tile_element *inputMapElement
|
|||
}
|
||||
break;
|
||||
case TILE_ELEMENT_TYPE_PATH:
|
||||
if (mapElement->properties.path.type & 0xF0) {
|
||||
if (mapElement->clearance_height == inputMapElement->base_height) {
|
||||
if (tileElement->properties.path.type & 0xF0) {
|
||||
if (tileElement->clearance_height == inputTileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_138B5A6);
|
||||
}
|
||||
if (mapElement->base_height == inputMapElement->clearance_height) {
|
||||
if (tileElement->base_height == inputTileElement->clearance_height) {
|
||||
proximity_score_increment(PROXIMITY_138B5A8);
|
||||
}
|
||||
} else {
|
||||
if (mapElement->clearance_height <= inputMapElement->base_height) {
|
||||
if (tileElement->clearance_height <= inputTileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_PATH_OVER);
|
||||
}
|
||||
if (mapElement->clearance_height == inputMapElement->base_height) {
|
||||
if (tileElement->clearance_height == inputTileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_PATH_TOUCH_ABOVE);
|
||||
}
|
||||
if (mapElement->base_height == inputMapElement->clearance_height) {
|
||||
if (tileElement->base_height == inputTileElement->clearance_height) {
|
||||
proximity_score_increment(PROXIMITY_PATH_TOUCH_UNDER);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case TILE_ELEMENT_TYPE_TRACK:
|
||||
{
|
||||
sint32 trackType = mapElement->properties.track.type;
|
||||
sint32 trackType = tileElement->properties.track.type;
|
||||
if (trackType == TRACK_ELEM_LEFT_VERTICAL_LOOP || trackType == TRACK_ELEM_RIGHT_VERTICAL_LOOP) {
|
||||
sint32 sequence = tile_element_get_track_sequence(mapElement);
|
||||
sint32 sequence = tile_element_get_track_sequence(tileElement);
|
||||
if (sequence == 3 || sequence == 6) {
|
||||
if (mapElement->base_height - inputMapElement->clearance_height <= 10) {
|
||||
if (tileElement->base_height - inputTileElement->clearance_height <= 10) {
|
||||
proximity_score_increment(PROXIMITY_THROUGH_VERTICAL_LOOP);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (inputMapElement->properties.track.ride_index != mapElement->properties.track.ride_index) {
|
||||
if (inputTileElement->properties.track.ride_index != tileElement->properties.track.ride_index) {
|
||||
proximity_score_increment(PROXIMITY_FOREIGN_TRACK_ABOVE_OR_BELOW);
|
||||
if (mapElement->clearance_height == inputMapElement->base_height) {
|
||||
if (tileElement->clearance_height == inputTileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_FOREIGN_TRACK_TOUCH_ABOVE);
|
||||
}
|
||||
if (mapElement->clearance_height + 2 <= inputMapElement->base_height) {
|
||||
if (mapElement->clearance_height + 10 >= inputMapElement->base_height) {
|
||||
if (tileElement->clearance_height + 2 <= inputTileElement->base_height) {
|
||||
if (tileElement->clearance_height + 10 >= inputTileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_FOREIGN_TRACK_CLOSE_ABOVE);
|
||||
}
|
||||
}
|
||||
if (inputMapElement->clearance_height == mapElement->base_height) {
|
||||
if (inputTileElement->clearance_height == tileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_FOREIGN_TRACK_TOUCH_ABOVE);
|
||||
}
|
||||
if (inputMapElement->clearance_height + 2 == mapElement->base_height) {
|
||||
if ((uint8)(inputMapElement->clearance_height + 10) >= mapElement->base_height) {
|
||||
if (inputTileElement->clearance_height + 2 == tileElement->base_height) {
|
||||
if ((uint8)(inputTileElement->clearance_height + 10) >= tileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_FOREIGN_TRACK_CLOSE_ABOVE);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
trackType = mapElement->properties.track.type;
|
||||
trackType = tileElement->properties.track.type;
|
||||
bool isStation = (
|
||||
trackType == TRACK_ELEM_END_STATION ||
|
||||
trackType == TRACK_ELEM_MIDDLE_STATION ||
|
||||
trackType == TRACK_ELEM_BEGIN_STATION
|
||||
);
|
||||
if (mapElement->clearance_height == inputMapElement->base_height) {
|
||||
if (tileElement->clearance_height == inputTileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_OWN_TRACK_TOUCH_ABOVE);
|
||||
if (isStation) {
|
||||
proximity_score_increment(PROXIMITY_OWN_STATION_TOUCH_ABOVE);
|
||||
}
|
||||
}
|
||||
if (mapElement->clearance_height + 2 <= inputMapElement->base_height) {
|
||||
if (mapElement->clearance_height + 10 >= inputMapElement->base_height) {
|
||||
if (tileElement->clearance_height + 2 <= inputTileElement->base_height) {
|
||||
if (tileElement->clearance_height + 10 >= inputTileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_OWN_TRACK_CLOSE_ABOVE);
|
||||
if (isStation) {
|
||||
proximity_score_increment(PROXIMITY_OWN_STATION_CLOSE_ABOVE);
|
||||
|
@ -588,14 +588,14 @@ static void ride_ratings_score_close_proximity(rct_tile_element *inputMapElement
|
|||
}
|
||||
}
|
||||
|
||||
if (inputMapElement->clearance_height == mapElement->base_height) {
|
||||
if (inputTileElement->clearance_height == tileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_OWN_TRACK_TOUCH_ABOVE);
|
||||
if (isStation) {
|
||||
proximity_score_increment(PROXIMITY_OWN_STATION_TOUCH_ABOVE);
|
||||
}
|
||||
}
|
||||
if (inputMapElement->clearance_height + 2 <= mapElement->base_height) {
|
||||
if (inputMapElement->clearance_height + 10 >= mapElement->base_height) {
|
||||
if (inputTileElement->clearance_height + 2 <= tileElement->base_height) {
|
||||
if (inputTileElement->clearance_height + 10 >= tileElement->base_height) {
|
||||
proximity_score_increment(PROXIMITY_OWN_TRACK_CLOSE_ABOVE);
|
||||
if (isStation) {
|
||||
proximity_score_increment(PROXIMITY_OWN_STATION_CLOSE_ABOVE);
|
||||
|
@ -605,12 +605,12 @@ static void ride_ratings_score_close_proximity(rct_tile_element *inputMapElement
|
|||
}
|
||||
} break;
|
||||
} // switch tile_element_get_type
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
|
||||
uint8 direction = tile_element_get_direction(inputMapElement);
|
||||
ride_ratings_score_close_proximity_in_direction(inputMapElement, (direction + 1) & 3);
|
||||
ride_ratings_score_close_proximity_in_direction(inputMapElement, (direction - 1) & 3);
|
||||
ride_ratings_score_close_proximity_loops(inputMapElement);
|
||||
uint8 direction = tile_element_get_direction(inputTileElement);
|
||||
ride_ratings_score_close_proximity_in_direction(inputTileElement, (direction + 1) & 3);
|
||||
ride_ratings_score_close_proximity_in_direction(inputTileElement, (direction - 1) & 3);
|
||||
ride_ratings_score_close_proximity_loops(inputTileElement);
|
||||
|
||||
switch (gRideRatingsCalcData.proximity_track_type) {
|
||||
case TRACK_ELEM_BRAKES:
|
||||
|
@ -1291,15 +1291,15 @@ static sint32 ride_ratings_get_scenery_score(Ride *ride)
|
|||
for (sint32 yy = max(y - 5, 0); yy <= min(y + 5, 255); yy++) {
|
||||
for (sint32 xx = max(x - 5, 0); xx <= min(x + 5, 255); xx++) {
|
||||
// Count scenery items on this tile
|
||||
rct_tile_element *mapElement = map_get_first_element_at(xx, yy);
|
||||
rct_tile_element *tileElement = map_get_first_element_at(xx, yy);
|
||||
do {
|
||||
if (mapElement->flags & (1 << 4))
|
||||
if (tileElement->flags & (1 << 4))
|
||||
continue;
|
||||
|
||||
sint32 type = tile_element_get_type(mapElement);
|
||||
sint32 type = tile_element_get_type(tileElement);
|
||||
if (type == TILE_ELEMENT_TYPE_SCENERY || type == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
|
||||
numSceneryItems++;
|
||||
} while (!tile_element_is_last_for_tile(mapElement++));
|
||||
} while (!tile_element_is_last_for_tile(tileElement++));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -30,7 +30,7 @@
|
|||
* rct2: 0x007630DE
|
||||
*/
|
||||
static void facility_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
bool hasSupports = wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_3], NULL);
|
||||
|
||||
|
|
|
@ -30,7 +30,7 @@
|
|||
* rct2: 0x007617A5
|
||||
*/
|
||||
static void shop_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
bool hasSupports = wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_3], NULL);
|
||||
|
||||
|
|
|
@ -26,7 +26,7 @@
|
|||
static void paint_3d_cinema_structure(paint_session * session, uint8 rideIndex, uint8 direction, sint8 xOffset, sint8 yOffset,
|
||||
uint16 height)
|
||||
{
|
||||
rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
|
||||
|
@ -53,7 +53,7 @@ static void paint_3d_cinema_structure(paint_session * session, uint8 rideIndex,
|
|||
sub_98197C(session, imageId, xOffset, yOffset, 24, 24, 47, height + 3, xOffset + 16, yOffset + 16, height + 3,
|
||||
get_current_rotation());
|
||||
|
||||
session->CurrentlyDrawnItem = savedMapElement;
|
||||
session->CurrentlyDrawnItem = savedTileElement;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
}
|
||||
|
||||
|
@ -61,7 +61,7 @@ static void paint_3d_cinema_structure(paint_session * session, uint8 rideIndex,
|
|||
* rct2: 0x0076574C
|
||||
*/
|
||||
static void paint_3d_cinema(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_3x3[direction][trackSequence];
|
||||
|
||||
|
@ -74,7 +74,7 @@ static void paint_3d_cinema(paint_session * session, uint8 rideIndex, uint8 trac
|
|||
track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
|
||||
get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
fenceSpritesRope, get_current_rotation());
|
||||
|
||||
switch (trackSequence)
|
||||
|
|
|
@ -23,11 +23,11 @@
|
|||
|
||||
/** rct2: 0x008A2ABC */
|
||||
static void paint_enterprise_structure(paint_session * session, Ride * ride, sint8 xOffset, sint8 yOffset, uint16 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
height += 7;
|
||||
|
||||
rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
|
||||
rct_vehicle * vehicle = NULL;
|
||||
|
||||
|
@ -45,7 +45,7 @@ static void paint_enterprise_structure(paint_session * session, Ride * ride, sin
|
|||
session->CurrentlyDrawnItem = vehicle;
|
||||
}
|
||||
|
||||
uint32 imageOffset = tile_element_get_direction_with_offset(mapElement, get_current_rotation());
|
||||
uint32 imageOffset = tile_element_get_direction_with_offset(tileElement, get_current_rotation());
|
||||
if (vehicle != NULL)
|
||||
{
|
||||
imageOffset = (vehicle->vehicle_sprite_type << 2) + (((vehicle->sprite_direction >> 3) + get_current_rotation()) % 4);
|
||||
|
@ -79,13 +79,13 @@ static void paint_enterprise_structure(paint_session * session, Ride * ride, sin
|
|||
}
|
||||
}
|
||||
|
||||
session->CurrentlyDrawnItem = savedMapElement;
|
||||
session->CurrentlyDrawnItem = savedTileElement;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
}
|
||||
|
||||
/** rct2: 0x008A1584 */
|
||||
static void paint_enterprise(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_4x4[direction][trackSequence];
|
||||
|
||||
|
@ -98,48 +98,48 @@ static void paint_enterprise(paint_session * session, uint8 rideIndex, uint8 tra
|
|||
track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
|
||||
get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
fenceSpritesRope, get_current_rotation());
|
||||
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 5:
|
||||
paint_enterprise_structure(session, ride, 16, 16, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, 16, 16, height, tileElement);
|
||||
break;
|
||||
case 6:
|
||||
paint_enterprise_structure(session, ride, 16, -16, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, 16, -16, height, tileElement);
|
||||
break;
|
||||
case 10:
|
||||
paint_enterprise_structure(session, ride, -16, -16, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, -16, -16, height, tileElement);
|
||||
break;
|
||||
case 9:
|
||||
paint_enterprise_structure(session, ride, -16, 16, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, -16, 16, height, tileElement);
|
||||
break;
|
||||
|
||||
case 0:
|
||||
paint_enterprise_structure(session, ride, 48, 48, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, 48, 48, height, tileElement);
|
||||
break;
|
||||
case 3:
|
||||
paint_enterprise_structure(session, ride, 48, -48, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, 48, -48, height, tileElement);
|
||||
break;
|
||||
case 15:
|
||||
paint_enterprise_structure(session, ride, -48, -48, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, -48, -48, height, tileElement);
|
||||
break;
|
||||
case 12:
|
||||
paint_enterprise_structure(session, ride, -48, 48, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, -48, 48, height, tileElement);
|
||||
break;
|
||||
|
||||
case 7:
|
||||
paint_enterprise_structure(session, ride, 16, -48, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, 16, -48, height, tileElement);
|
||||
break;
|
||||
case 11:
|
||||
paint_enterprise_structure(session, ride, -16, -48, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, -16, -48, height, tileElement);
|
||||
break;
|
||||
case 14:
|
||||
paint_enterprise_structure(session, ride, -48, -16, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, -48, -16, height, tileElement);
|
||||
break;
|
||||
case 13:
|
||||
paint_enterprise_structure(session, ride, -48, 16, height, mapElement);
|
||||
paint_enterprise_structure(session, ride, -48, 16, height, tileElement);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
@ -132,7 +132,7 @@ static const uint32 go_karts_track_pieces_25_deg_up_to_flat[4][2] = {
|
|||
|
||||
/** rct2: 0x0074A748 */
|
||||
static void paint_go_karts_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
if (direction == 0 || direction == 2)
|
||||
|
@ -164,7 +164,7 @@ static void paint_go_karts_track_flat(paint_session * session, uint8 rideIndex,
|
|||
|
||||
/** rct2: 0x0074A758 */
|
||||
static void paint_go_karts_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
paint_struct * ps;
|
||||
|
@ -217,7 +217,7 @@ static void paint_go_karts_track_25_deg_up(paint_session * session, uint8 rideIn
|
|||
|
||||
/** rct2: 0x0074A768 */
|
||||
static void paint_go_karts_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
paint_struct * ps;
|
||||
|
@ -270,7 +270,7 @@ static void paint_go_karts_track_flat_to_25_deg_up(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x */
|
||||
static void paint_go_karts_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
paint_struct * ps;
|
||||
|
@ -323,28 +323,28 @@ static void paint_go_karts_track_25_deg_up_to_flat(paint_session * session, uint
|
|||
|
||||
/** rct2: 0x0074A788 */
|
||||
static void paint_go_karts_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_go_karts_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_go_karts_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0074A798 */
|
||||
static void paint_go_karts_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_go_karts_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_go_karts_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x0074A7A8 */
|
||||
static void paint_go_karts_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_go_karts_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
|
||||
paint_go_karts_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/** rct2: 0x */
|
||||
static void paint_go_karts_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
LocationXY16 position = session->MapPosition;
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
|
@ -354,7 +354,7 @@ static void paint_go_karts_station(paint_session * session, uint8 rideIndex, uin
|
|||
uint32 imageId;
|
||||
const uint32(*sprites)[2] = go_karts_track_pieces_starting_grid;
|
||||
|
||||
if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
|
||||
if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
|
||||
{
|
||||
sprites = go_karts_track_pieces_starting_grid_end;
|
||||
}
|
||||
|
@ -371,12 +371,12 @@ static void paint_go_karts_station(paint_session * session, uint8 rideIndex, uin
|
|||
|
||||
if (direction == 0 || direction == 2)
|
||||
{
|
||||
hasFence = track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, get_current_rotation());
|
||||
hasFence = track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, get_current_rotation());
|
||||
track_paint_util_draw_station_covers(session, EDGE_NW, hasFence, entranceStyle, direction, height);
|
||||
}
|
||||
else
|
||||
{
|
||||
hasFence = track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, get_current_rotation());
|
||||
hasFence = track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, get_current_rotation());
|
||||
track_paint_util_draw_station_covers(session, EDGE_NE, hasFence, entranceStyle, direction, height);
|
||||
}
|
||||
|
||||
|
@ -396,18 +396,18 @@ static void paint_go_karts_station(paint_session * session, uint8 rideIndex, uin
|
|||
|
||||
if (direction == 0 || direction == 2)
|
||||
{
|
||||
hasFence = track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation());
|
||||
hasFence = track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation());
|
||||
track_paint_util_draw_station_covers(session, EDGE_SE, hasFence, entranceStyle, direction, height);
|
||||
}
|
||||
else
|
||||
{
|
||||
hasFence = track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation());
|
||||
hasFence = track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation());
|
||||
track_paint_util_draw_station_covers(session, EDGE_SW, hasFence, entranceStyle, direction, height);
|
||||
}
|
||||
|
||||
if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
|
||||
if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
|
||||
{
|
||||
const bool hasGreenLight = tile_element_get_green_light(mapElement);
|
||||
const bool hasGreenLight = tile_element_get_green_light(tileElement);
|
||||
|
||||
switch (direction)
|
||||
{
|
||||
|
@ -454,7 +454,7 @@ static void paint_go_karts_station(paint_session * session, uint8 rideIndex, uin
|
|||
|
||||
/** rct2: 0x0074A7E8 */
|
||||
static void paint_go_karts_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint32 imageId;
|
||||
|
||||
|
@ -523,9 +523,9 @@ static void paint_go_karts_track_left_quarter_turn_1_tile(paint_session * sessio
|
|||
|
||||
/** rct2: 0x0074A7F8 */
|
||||
static void paint_go_karts_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
paint_go_karts_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, mapElement);
|
||||
paint_go_karts_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, tileElement);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -92,7 +92,7 @@ void vehicle_visual_launched_freefall(paint_session * session, sint32 x, sint32
|
|||
|
||||
/** rct2: 0x006FD1F8 */
|
||||
static void paint_launched_freefall_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_3x3[direction][trackSequence];
|
||||
|
||||
|
@ -105,7 +105,7 @@ static void paint_launched_freefall_base(paint_session * session, uint8 rideInde
|
|||
uint32 imageId = SPR_FLOOR_METAL | session->TrackColours[SCHEME_SUPPORTS];
|
||||
sub_98197C(session, imageId, 0, 0, 32, 32, 1, height, 0, 0, height, get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
launched_freefall_fence_sprites, get_current_rotation());
|
||||
|
||||
if (trackSequence == 0)
|
||||
|
@ -164,7 +164,7 @@ static void paint_launched_freefall_base(paint_session * session, uint8 rideInde
|
|||
|
||||
/** rct2: 0x006FD208 */
|
||||
static void paint_launched_freefall_tower_section(paint_session * session, uint8 rideIndex, uint8 trackSequence,
|
||||
uint8 direction, sint32 height, rct_tile_element * mapElement)
|
||||
uint8 direction, sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (trackSequence == 1)
|
||||
{
|
||||
|
@ -174,8 +174,8 @@ static void paint_launched_freefall_tower_section(paint_session * session, uint8
|
|||
uint32 imageId = SPR_LAUNCHED_FREEFALL_TOWER_SEGMENT | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
|
||||
|
||||
rct_tile_element * nextMapElement = mapElement + 1;
|
||||
if (tile_element_is_last_for_tile(mapElement) || mapElement->clearance_height != nextMapElement->base_height)
|
||||
rct_tile_element * nextTileElement = tileElement + 1;
|
||||
if (tile_element_is_last_for_tile(tileElement) || tileElement->clearance_height != nextTileElement->base_height)
|
||||
{
|
||||
imageId = SPR_LAUNCHED_FREEFALL_TOWER_SEGMENT_TOP | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98199C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
|
||||
|
|
|
@ -174,7 +174,7 @@ static void paint_magic_carpet_vehicle(paint_session * session, Ride * ride, uin
|
|||
/** rct2: 0x00899104 */
|
||||
static void paint_magic_carpet_structure(paint_session * session, Ride * ride, uint8 direction, sint8 axisOffset, uint16 height)
|
||||
{
|
||||
rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_vehicle * vehicle = get_first_vehicle(ride);
|
||||
|
||||
uint32 swingImageId = 0;
|
||||
|
@ -204,12 +204,12 @@ static void paint_magic_carpet_structure(paint_session * session, Ride * ride, u
|
|||
paint_magic_carpet_frame(session, PLANE_FRONT, direction, offset, bbOffset, bbSize);
|
||||
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
session->CurrentlyDrawnItem = savedMapElement;
|
||||
session->CurrentlyDrawnItem = savedTileElement;
|
||||
}
|
||||
|
||||
/** rct2: 0x00898514 */
|
||||
static void paint_magic_carpet(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
uint8 relativeTrackSequence = track_map_1x4[direction][trackSequence];
|
||||
|
||||
|
|
|
@ -37,12 +37,12 @@ enum
|
|||
* rct2: 0x0076522A
|
||||
*/
|
||||
static void paint_motionsimulator_vehicle(paint_session * session, sint8 offsetX, sint8 offsetY, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
Ride * ride = get_ride(mapElement->properties.track.ride_index);
|
||||
Ride * ride = get_ride(tileElement->properties.track.ride_index);
|
||||
rct_ride_entry * rideEntry = get_ride_entry_by_ride(ride);
|
||||
|
||||
rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
|
||||
rct_vehicle * vehicle = NULL;
|
||||
if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)
|
||||
|
@ -128,13 +128,13 @@ static void paint_motionsimulator_vehicle(paint_session * session, sint8 offsetX
|
|||
break;
|
||||
}
|
||||
|
||||
session->CurrentlyDrawnItem = savedMapElement;
|
||||
session->CurrentlyDrawnItem = savedTileElement;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
}
|
||||
|
||||
/** rct2: 0x008A85C4 */
|
||||
static void paint_motionsimulator(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_2x2[direction][trackSequence];
|
||||
|
||||
|
@ -145,19 +145,19 @@ static void paint_motionsimulator(paint_session * session, uint8 rideIndex, uint
|
|||
wooden_a_supports_paint_setup(session, (direction & 1), 0, height, session->TrackColours[SCHEME_MISC], NULL);
|
||||
track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
|
||||
get_current_rotation());
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
|
||||
fenceSpritesRope, get_current_rotation());
|
||||
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 1:
|
||||
paint_motionsimulator_vehicle(session, 16, -16, direction, height, mapElement);
|
||||
paint_motionsimulator_vehicle(session, 16, -16, direction, height, tileElement);
|
||||
break;
|
||||
case 2:
|
||||
paint_motionsimulator_vehicle(session, -16, 16, direction, height, mapElement);
|
||||
paint_motionsimulator_vehicle(session, -16, 16, direction, height, tileElement);
|
||||
break;
|
||||
case 3:
|
||||
paint_motionsimulator_vehicle(session, -16, -16, direction, height, mapElement);
|
||||
paint_motionsimulator_vehicle(session, -16, -16, direction, height, tileElement);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
@ -65,7 +65,7 @@ static void paint_pirate_ship_structure(paint_session * session, Ride * ride, ui
|
|||
{
|
||||
uint32 imageId, baseImageId;
|
||||
|
||||
rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
|
||||
rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
|
||||
rct_vehicle * vehicle = NULL;
|
||||
|
@ -162,13 +162,13 @@ static void paint_pirate_ship_structure(paint_session * session, Ride * ride, ui
|
|||
sub_98199C(session, imageId, xOffset, yOffset, bounds.length_x, bounds.length_y, 80, height, bounds.offset_x,
|
||||
bounds.offset_y, height, get_current_rotation());
|
||||
|
||||
session->CurrentlyDrawnItem = savedMapElement;
|
||||
session->CurrentlyDrawnItem = savedTileElement;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
}
|
||||
|
||||
/** rct2: 0x008A85C4 */
|
||||
static void paint_pirate_ship(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
uint8 relativeTrackSequence = track_map_1x5[direction][trackSequence];
|
||||
Ride * ride = get_ride(rideIndex);
|
||||
|
@ -204,7 +204,7 @@ static void paint_pirate_ship(paint_session * session, uint8 rideIndex, uint8 tr
|
|||
{
|
||||
if (relativeTrackSequence != 1 && relativeTrackSequence != 4)
|
||||
{
|
||||
hasFence = track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, get_current_rotation());
|
||||
hasFence = track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, get_current_rotation());
|
||||
if (relativeTrackSequence == 2)
|
||||
{
|
||||
imageId = (hasFence ? SPR_STATION_PLATFORM_BEGIN_FENCED_NW_SE : SPR_STATION_PLATFORM_BEGIN_NW_SE) |
|
||||
|
@ -221,7 +221,7 @@ static void paint_pirate_ship(paint_session * session, uint8 rideIndex, uint8 tr
|
|||
session->TrackColours[SCHEME_TRACK];
|
||||
sub_98196C(session, imageId, 24, 0, 8, 32, 1, height + 9, get_current_rotation());
|
||||
|
||||
hasFence = track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation());
|
||||
hasFence = track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation());
|
||||
if (relativeTrackSequence == 3)
|
||||
{
|
||||
if (hasFence)
|
||||
|
@ -249,7 +249,7 @@ static void paint_pirate_ship(paint_session * session, uint8 rideIndex, uint8 tr
|
|||
{
|
||||
if (relativeTrackSequence != 1 && relativeTrackSequence != 4)
|
||||
{
|
||||
hasFence = track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, get_current_rotation());
|
||||
hasFence = track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, get_current_rotation());
|
||||
if (relativeTrackSequence == 2)
|
||||
{
|
||||
imageId = (hasFence ? SPR_STATION_PLATFORM_BEGIN_FENCED_SW_NE : SPR_STATION_PLATFORM_BEGIN_SW_NE) |
|
||||
|
@ -266,7 +266,7 @@ static void paint_pirate_ship(paint_session * session, uint8 rideIndex, uint8 tr
|
|||
session->TrackColours[SCHEME_TRACK];
|
||||
sub_98196C(session, imageId, 0, 24, 32, 8, 1, height + 9, get_current_rotation());
|
||||
|
||||
hasFence = track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation());
|
||||
hasFence = track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation());
|
||||
if (relativeTrackSequence == 3)
|
||||
{
|
||||
if (hasFence)
|
||||
|
|
|
@ -92,7 +92,7 @@ void vehicle_visual_roto_drop(paint_session * session, sint32 x, sint32 imageDir
|
|||
|
||||
/** rct2: 0x00886194 */
|
||||
static void paint_roto_drop_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_3x3[direction][trackSequence];
|
||||
|
||||
|
@ -105,7 +105,7 @@ static void paint_roto_drop_base(paint_session * session, uint8 rideIndex, uint8
|
|||
uint32 imageId = SPR_FLOOR_METAL_B | session->TrackColours[SCHEME_SUPPORTS];
|
||||
sub_98197C(session, imageId, 0, 0, 32, 32, 1, height, 0, 0, height, get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
|
||||
fenceSpritesMetalB, get_current_rotation());
|
||||
|
||||
if (trackSequence == 0)
|
||||
|
@ -169,7 +169,7 @@ static void paint_roto_drop_base(paint_session * session, uint8 rideIndex, uint8
|
|||
|
||||
/** rct2: 0x008861A4 */
|
||||
static void paint_roto_drop_tower_section(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
if (trackSequence == 1)
|
||||
{
|
||||
|
@ -179,8 +179,8 @@ static void paint_roto_drop_tower_section(paint_session * session, uint8 rideInd
|
|||
uint32 imageId = SPR_ROTO_DROP_TOWER_SEGMENT | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98197C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
|
||||
|
||||
rct_tile_element * nextMapElement = mapElement + 1;
|
||||
if (tile_element_is_last_for_tile(mapElement) || mapElement->clearance_height != nextMapElement->base_height)
|
||||
rct_tile_element * nextTileElement = tileElement + 1;
|
||||
if (tile_element_is_last_for_tile(tileElement) || tileElement->clearance_height != nextTileElement->base_height)
|
||||
{
|
||||
imageId = SPR_ROTO_DROP_TOWER_SEGMENT_TOP | session->TrackColours[SCHEME_TRACK];
|
||||
sub_98199C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
|
||||
|
|
|
@ -55,7 +55,7 @@ static const uint32 swinging_inverter_ship_frame_sprites[] = { SPR_SWINGING_INVE
|
|||
static void paint_swinging_inverter_ship_structure(paint_session * session, Ride * ride, uint8 direction, sint8 axisOffset,
|
||||
uint16 height)
|
||||
{
|
||||
rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
|
||||
rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
|
||||
rct_vehicle * vehicle = NULL;
|
||||
|
@ -118,13 +118,13 @@ static void paint_swinging_inverter_ship_structure(paint_session * session, Ride
|
|||
boundBox.offset_x, boundBox.offset_y, height, get_current_rotation());
|
||||
}
|
||||
|
||||
session->CurrentlyDrawnItem = savedMapElement;
|
||||
session->CurrentlyDrawnItem = savedTileElement;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
}
|
||||
|
||||
/** rct2: 0x00760260 */
|
||||
static void paint_swinging_inverter_ship(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
|
||||
sint32 height, rct_tile_element * mapElement)
|
||||
sint32 height, rct_tile_element * tileElement)
|
||||
{
|
||||
uint8 relativeTrackSequence = track_map_1x4[direction][trackSequence];
|
||||
|
||||
|
|
|
@ -48,12 +48,12 @@ static sint8 TopSpinSeatPositionOffset[] = {
|
|||
* rct2: 0x0076750D
|
||||
*/
|
||||
static void top_spin_paint_vehicle(paint_session * session, sint8 al, sint8 cl, uint8 rideIndex, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
uint16 boundBoxOffsetX, boundBoxOffsetY, boundBoxOffsetZ;
|
||||
// As we will be drawing a vehicle we need to backup the mapElement that
|
||||
// As we will be drawing a vehicle we need to backup the tileElement that
|
||||
// is assigned to the drawings.
|
||||
rct_tile_element * curMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
rct_tile_element * curTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
|
||||
|
||||
height += 3;
|
||||
|
||||
|
@ -240,7 +240,7 @@ static void top_spin_paint_vehicle(paint_session * session, sint8 al, sint8 cl,
|
|||
sub_98199C(session, image_id, al, cl, lengthX, lengthY, 90, height, boundBoxOffsetX, boundBoxOffsetY, boundBoxOffsetZ,
|
||||
rotation);
|
||||
|
||||
session->CurrentlyDrawnItem = curMapElement;
|
||||
session->CurrentlyDrawnItem = curTileElement;
|
||||
session->InteractionType = VIEWPORT_INTERACTION_ITEM_RIDE;
|
||||
}
|
||||
|
||||
|
@ -248,7 +248,7 @@ static void top_spin_paint_vehicle(paint_session * session, sint8 al, sint8 cl,
|
|||
* rct2: 0x0076679C
|
||||
*/
|
||||
static void paint_top_spin(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
|
||||
rct_tile_element * mapElement)
|
||||
rct_tile_element * tileElement)
|
||||
{
|
||||
trackSequence = track_map_3x3[direction][trackSequence];
|
||||
|
||||
|
@ -261,28 +261,28 @@ static void paint_top_spin(paint_session * session, uint8 rideIndex, uint8 track
|
|||
track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
|
||||
get_current_rotation());
|
||||
|
||||
track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
|
||||
fenceSpritesRope, get_current_rotation());
|
||||
|
||||
switch (trackSequence)
|
||||
{
|
||||
case 1:
|
||||
top_spin_paint_vehicle(session, 32, 32, rideIndex, direction, height, mapElement);
|
||||
top_spin_paint_vehicle(session, 32, 32, rideIndex, direction, height, tileElement);
|
||||
break;
|
||||
case 3:
|
||||
top_spin_paint_vehicle(session, 32, -32, rideIndex, direction, height, mapElement);
|
||||
top_spin_paint_vehicle(session, 32, -32, rideIndex, direction, height, tileElement);
|
||||
break;
|
||||
case 5:
|
||||
top_spin_paint_vehicle(session, 0, -32, rideIndex, direction, height, mapElement);
|
||||
top_spin_paint_vehicle(session, 0, -32, rideIndex, direction, height, tileElement);
|
||||
break;
|
||||
case 6:
|
||||
top_spin_paint_vehicle(session, -32, 32, rideIndex, direction, height, mapElement);
|
||||
top_spin_paint_vehicle(session, -32, 32, rideIndex, direction, height, tileElement);
|
||||
break;
|
||||
case 7:
|
||||
top_spin_paint_vehicle(session, -32, -32, rideIndex, direction, height, mapElement);
|
||||
top_spin_paint_vehicle(session, -32, -32, rideIndex, direction, height, tileElement);
|
||||
break;
|
||||
case 8:
|
||||
top_spin_paint_vehicle(session, -32, 0, rideIndex, direction, height, mapElement);
|
||||
top_spin_paint_vehicle(session, -32, 0, rideIndex, direction, height, tileElement);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue