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

1901 lines
75 KiB
C
Raw Normal View History

Add and correct licence headers to all sources (#3108)
2016-05-04 19:24:41 +02:00
#pragma region Copyright (c) 2014-2016 OpenRCT2 Developers
add track definitions
2014-04-23 02:50:40 +02:00
/*****************************************************************************
* OpenRCT2, an open source clone of Roller Coaster Tycoon 2.
*
Add and correct licence headers to all sources (#3108)
2016-05-04 19:24:41 +02:00
* OpenRCT2 is the work of many authors, a full list can be found in contributors.md
* For more information, visit https://github.com/OpenRCT2/OpenRCT2
add track definitions
2014-04-23 02:50:40 +02:00
*
* OpenRCT2 is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
Add and correct licence headers to all sources (#3108)
2016-05-04 19:24:41 +02:00
*
* A full copy of the GNU General Public License can be found in licence.txt
add track definitions
2014-04-23 02:50:40 +02:00
*****************************************************************************/
Add and correct licence headers to all sources (#3108)
2016-05-04 19:24:41 +02:00
#pragma endregion
add track definitions
2014-04-23 02:50:40 +02:00
organisation: fix includes
2014-10-06 18:36:58 +02:00
#include "../addresses.h"
Add more to the ride track save
2015-02-26 22:56:51 +01:00
#include "../audio/audio.h"
prepare track place and remove game commands
2015-06-27 18:53:28 +02:00
#include "../cheats.h"
Allow building in pause mode via a cheat
2015-06-10 18:12:21 +02:00
#include "../config.h"
move osinterface code to shared or windows
2015-02-12 21:51:40 +01:00
#include "../game.h"
#include "../interface/viewport.h"
#include "../localisation/localisation.h"
prepare track place and remove game commands
2015-06-27 18:53:28 +02:00
#include "../management/finance.h"
more accurate last player action location
2016-01-25 05:00:31 +01:00
#include "../network/network.h"
move osinterface code to shared or windows
2015-02-12 21:51:40 +01:00
#include "../platform/platform.h"
#include "../rct1.h"
change track loading to use stdio (FILE)
2014-10-11 02:18:08 +02:00
#include "../util/sawyercoding.h"
#include "../util/util.h"
prepare track place and remove game commands
2015-06-27 18:53:28 +02:00
#include "../world/map_animation.h"
move osinterface code to shared or windows
2015-02-12 21:51:40 +01:00
#include "../world/park.h"
Added more of scenery place
2015-05-03 21:31:02 +02:00
#include "../world/scenery.h"
Started scenery placement
2015-05-03 18:06:27 +02:00
#include "../world/footpath.h"
Add more to the ride track save
2015-02-26 22:56:51 +01:00
#include "../windows/error.h"
start implementation of track list window
2014-09-27 01:41:24 +02:00
#include "ride.h"
implement RideData4 data
2015-09-10 23:16:41 +02:00
#include "ride_data.h"
prepare track place and remove game commands
2015-06-27 18:53:28 +02:00
#include "ride_ratings.h"
add track definitions
2014-04-23 02:50:40 +02:00
#include "track.h"
Finished save track for tracked rides. Still needs mazes to be done. No noticable bugs so far.
2015-04-26 23:06:08 +02:00
#include "track_data.h"
add track definitions
2014-04-23 02:50:40 +02:00
integrate ground flag variables
2016-05-17 21:51:11 +02:00
uint8 gTrackGroundFlags;
add track definitions
2014-04-23 02:50:40 +02:00
/**
*
* rct2: 0x00997C9D
*/
further testing and progress on set_ride_status
2015-01-29 22:10:34 +01:00
const rct_trackdefinition *gTrackDefinitions = (rct_trackdefinition*)0x00997C9D;
implement ride_construction_set_default_next_piece
2015-07-13 13:47:31 +02:00
const rct_trackdefinition *gFlatRideTrackDefinitions = (rct_trackdefinition*)0x0099849D;
further testing and progress on set_ride_status
2015-01-29 22:10:34 +01:00
// TODO This table is incorrect or at least missing 69 elements. There should be 256 in total!
const rct_trackdefinition gTrackDefinitions_INCORRECT[] = {
Convert spaces to tabs
2015-12-11 13:28:35 +01:00
// TYPE VANGLE END VANGLE START BANK END BANK START SPECIAL
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_END_STATION
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_BEGIN_STATION
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_MIDDLE_STATION
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT_TO_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_UP_TO_60_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_UP_TO_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_UP_TO_FLAT
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT_TO_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_DOWN_TO_60_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_DOWN_TO_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_DOWN_TO_FLAT
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_5_TILES
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_5_TILES
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT_TO_LEFT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT_TO_RIGHT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_BANK_TO_FLAT
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_BANK_TO_FLAT
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_BANKED_LEFT_QUARTER_TURN_5_TILES
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_BANKED_RIGHT_QUARTER_TURN_5_TILES
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_BANK_TO_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_BANK_TO_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_LEFT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_UP_TO_LEFT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_RIGHT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_UP_TO_RIGHT_BANK
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_BANK_TO_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_BANK_TO_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_25, TRACK_BANK_LEFT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_DOWN_TO_LEFT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_25, TRACK_BANK_RIGHT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_DOWN_TO_RIGHT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_BANK
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_5_TILES_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_5_TILES_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_5_TILES_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_5_TILES_25_DEG_DOWN
{ TRACK_S_BEND, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_S_BEND_LEFT
{ TRACK_S_BEND, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_S_BEND_RIGHT
{ TRACK_VERTICAL_LOOP, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_UNKNOWN_VERTICAL_LOOP }, // ELEM_LEFT_VERTICAL_LOOP
{ TRACK_VERTICAL_LOOP, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_UNKNOWN_VERTICAL_LOOP }, // ELEM_RIGHT_VERTICAL_LOOP
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_3_TILES
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_3_TILES
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_3_TILES_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_3_TILES_BANK
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_3_TILES_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_3_TILES_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_3_TILES_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_3_TILES_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_1_TILE
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_1_TILE
{ TRACK_TWIST, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_TWIST_DOWN_TO_UP
{ TRACK_TWIST, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_TWIST_DOWN_TO_UP
{ TRACK_TWIST, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_NONE }, // ELEM_LEFT_TWIST_UP_TO_DOWN
{ TRACK_TWIST, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_NONE }, // ELEM_RIGHT_TWIST_UP_TO_DOWN
{ TRACK_HALF_LOOP, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, TRACK_HALF_LOOP_UP }, // ELEM_HALF_LOOP_UP
{ TRACK_HALF_LOOP, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_HALF_LOOP_DOWN }, // ELEM_HALF_LOOP_DOWN
{ TRACK_CORKSCREW, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_CORKSCREW_UP
{ TRACK_CORKSCREW, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_CORKSCREW_UP
{ TRACK_CORKSCREW, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_CORKSCREW_DOWN }, // ELEM_LEFT_CORKSCREW_DOWN
{ TRACK_CORKSCREW, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_CORKSCREW_DOWN }, // ELEM_RIGHT_CORKSCREW_DOWN
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT_TO_60_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_UP_TO_FLAT
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT_TO_60_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_DOWN_TO_FLAT
{ TRACK_TOWER_BASE, TRACK_VANGLE_TOWER, TRACK_VANGLE_TOWER, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_TOWER_BASE
{ TRACK_TOWER_BASE, TRACK_VANGLE_TOWER, TRACK_VANGLE_TOWER, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_TOWER_SECTION
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT_COVERED
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_UP_COVERED
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_UP_COVERED
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT_TO_25_DEG_UP_COVERED
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_UP_TO_60_DEG_UP_COVERED
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_UP_TO_25_DEG_UP_COVERED
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_UP_TO_FLAT_COVERED
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_DOWN_COVERED
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_DOWN_COVERED
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT_TO_25_DEG_DOWN_COVERED
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_DOWN_TO_60_DEG_DOWN_COVERED
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_DOWN_TO_25_DEG_DOWN_COVERED
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_25_DEG_DOWN_TO_FLAT_COVERED
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_5_TILES_COVERED
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_5_TILES_COVERED
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_S_BEND_LEFT_COVERED
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_S_BEND_RIGHT_COVERED
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_3_TILES_COVERED
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_3_TILES_COVERED
{ TRACK_HELIX_SMALL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_HALF_BANKED_HELIX_UP_SMALL
{ TRACK_HELIX_SMALL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_HALF_BANKED_HELIX_UP_SMALL
{ TRACK_HELIX_SMALL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_HALF_BANKED_HELIX_DOWN_SMALL
{ TRACK_HELIX_SMALL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_HALF_BANKED_HELIX_DOWN_SMALL
{ TRACK_HELIX_SMALL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_HALF_BANKED_HELIX_UP_LARGE
{ TRACK_HELIX_SMALL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_HALF_BANKED_HELIX_UP_LARGE
{ TRACK_HELIX_SMALL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_HALF_BANKED_HELIX_DOWN_LARGE
{ TRACK_HELIX_SMALL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_HALF_BANKED_HELIX_DOWN_LARGE
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_1_TILE_60_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_1_TILE_60_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_1_TILE_60_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_1_TILE_60_DEG_DOWN
{ TRACK_BRAKES, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_BRAKES
{ TRACK_ROTATION_CONTROL_TOGGLE,TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_ROTATION_CONTROL_TOGGLE
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_INVERTED_90_DEG_UP_TO_FLAT_QUARTER_LOOP
{ TRACK_HELIX_LARGE, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_QUARTER_BANKED_HELIX_LARGE_UP
{ TRACK_HELIX_LARGE, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_QUARTER_BANKED_HELIX_LARGE_UP
{ TRACK_HELIX_LARGE, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_QUARTER_BANKED_HELIX_LARGE_DOWN
{ TRACK_HELIX_LARGE, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_QUARTER_BANKED_HELIX_LARGE_DOWN
{ TRACK_HELIX_LARGE_UNBANKED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_HELIX_LARGE_UP
{ TRACK_HELIX_LARGE_UNBANKED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_HELIX_LARGE_UP
{ TRACK_HELIX_LARGE_UNBANKED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_HELIX_LARGE_DOWN
{ TRACK_HELIX_LARGE_UNBANKED, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_HELIX_LARGE_DOWN
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_25, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_25_DEG_UP_LEFT_BANKED
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_25, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_25_DEG_UP_RIGHT_BANKED
{ TRACK_WATERFALL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_WATERFALL
{ TRACK_RAPIDS, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RAPIDS
{ TRACK_ON_RIDE_PHOTO, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_ON_RIDE_PHOTO
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_25, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_25_DEG_DOWN_LEFT_BANKED
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_25, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_25_DEG_DOWN_RIGHT_BANKED
{ TRACK_WATER_SPLASH, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_WATER_SPLASH
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT_TO_60_DEG_UP_LONG_BASE
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_UP_TO_FLAT_LONG_BASE
{ TRACK_WHIRLPOOL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_WHIRLPOOL
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_FLAT_TO_60_DEG_DOWN_LONG_BASE
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_UP_TO_FLAT_LONG_BASE
{ TRACK_LIFT_HILL, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_CABLE_LIFT_HILL
{ TRACK_WHOA_BELLY, TRACK_VANGLE_WHOA_BELLY, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_REVERSE_WHOA_BELLY_SLOPE
{ TRACK_WHOA_BELLY, TRACK_VANGLE_WHOA_BELLY, TRACK_VANGLE_WHOA_BELLY, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_REVERSE_WHOA_BELLY_VERTICAL
{ TRACK_FLAT, TRACK_SLOPE_UP_90, TRACK_SLOPE_UP_90, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_90_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_DOWN_90, TRACK_SLOPE_DOWN_90, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_90_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_UP_90, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_UP_TO_90_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_DOWN_90, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_90_DEG_DOWN_TO_60_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_UP_90, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_90_DEG_UP_TO_60_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_DOWN_90, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_60_DEG_DOWN_TO_90_DEG_DOWN
{ TRACK_BRAKE_FOR_DROP, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_BRAKE_FOR_DROP
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_EIGHTH_TO_DIAG
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_EIGHTH_TO_DIAG
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_EIGHTH_TO_ORTHOGONAL
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_EIGHTH_TO_ORTHOGONAL
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_EIGHTH_BANK_TO_DIAG
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_EIGHTH_BANK_TO_DIAG
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_EIGHTH_BANK_TO_ORTHOGONAL
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_EIGHTH_BANK_TO_ORTHOGONAL
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_FLAT
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_60_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_FLAT_TO_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_25_DEG_UP_TO_60_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_60_DEG_UP_TO_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_25_DEG_UP_TO_FLAT
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_60_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_FLAT_TO_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_25_DEG_DOWN_TO_60_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_60_DEG_DOWN_TO_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_25_DEG_DOWN_TO_FLAT
{ TRACK_FLAT, TRACK_SLOPE_UP_60, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_FLAT_TO_60_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_60_DEG_UP_TO_FLAT
{ TRACK_FLAT, TRACK_SLOPE_DOWN_60, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_FLAT_TO_60_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_60, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_60_DEG_DOWN_TO_FLAT
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_FLAT_TO_LEFT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_FLAT_TO_RIGHT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_DIAG_LEFT_BANK_TO_FLAT
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_DIAG_RIGHT_BANK_TO_FLAT
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_DIAG_LEFT_BANK_TO_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_DIAG_RIGHT_BANK_TO_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_LEFT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_25_DEG_UP_TO_LEFT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_RIGHT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_25_DEG_UP_TO_RIGHT_BANK
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_DIAG_LEFT_BANK_TO_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_DIAG_RIGHT_BANK_TO_25_DEG_DOWN
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_25, TRACK_BANK_LEFT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_25_DEG_DOWN_TO_LEFT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_25, TRACK_BANK_RIGHT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_DIAG_25_DEG_DOWN_TO_RIGHT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_LEFT, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_DIAG_LEFT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_RIGHT, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_DIAG_RIGHT_BANK
{ TRACK_LOG_FLUME_REVERSER, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LOG_FLUME_REVERSER
{ TRACK_SPINNING_TUNNEL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_SPINNING_TUNNEL
{ TRACK_BARREL_ROLL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_BARREL_ROLL_UP_TO_DOWN
{ TRACK_BARREL_ROLL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_BARREL_ROLL_UP_TO_DOWN
{ TRACK_BARREL_ROLL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_NONE }, // ELEM_LEFT_BARREL_ROLL_DOWN_TO_UP
{ TRACK_BARREL_ROLL, TRACK_SLOPE_NONE, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_NONE }, // ELEM_RIGHT_BARREL_ROLL_DOWN_TO_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_LEFT, TRACK_NONE }, // ELEM_LEFT_BANK_TO_LEFT_QUARTER_TURN_3_TILES_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_UP_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_RIGHT, TRACK_NONE }, // ELEM_RIGHT_BANK_TO_RIGHT_QUARTER_TURN_3_TILES_25_DEG_UP
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_25, TRACK_BANK_LEFT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_LEFT_QUARTER_TURN_3_TILES_25_DEG_DOWN_TO_LEFT_BANK
{ TRACK_FLAT, TRACK_SLOPE_NONE, TRACK_SLOPE_DOWN_25, TRACK_BANK_RIGHT, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_RIGHT_QUARTER_TURN_3_TILES_25_DEG_DOWN_TO_RIGHT_BANK
{ TRACK_POWERED_LIFT, TRACK_SLOPE_UP_25, TRACK_SLOPE_UP_25, TRACK_BANK_NONE, TRACK_BANK_NONE, TRACK_NONE }, // ELEM_POWERED_LIFT
{ TRACK_HALF_LOOP_LARGE, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, TRACK_HALF_LOOP_UP }, // ELEM_LEFT_LARGE_HALF_LOOP_UP
{ TRACK_HALF_LOOP_LARGE, TRACK_SLOPE_NONE, TRACK_SLOPE_UP_25, TRACK_BANK_UPSIDE_DOWN, TRACK_BANK_NONE, TRACK_HALF_LOOP_UP }, // ELEM_RIGHT_LARGE_HALF_LOOP_UP
{ TRACK_HALF_LOOP_LARGE, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_HALF_LOOP_DOWN }, // ELEM_RIGHT_LARGE_HALF_LOOP_DOWN
{ TRACK_HALF_LOOP_LARGE, TRACK_SLOPE_DOWN_25, TRACK_SLOPE_NONE, TRACK_BANK_NONE, TRACK_BANK_UPSIDE_DOWN, TRACK_HALF_LOOP_DOWN }, // ELEM_LEFT_LARGE_HALF_LOOP_DOWN
add track definitions
2014-04-23 02:50:40 +02:00
};
implement track save select nearby scenery
2015-06-07 17:02:43 +02:00
/**
move track design related functions to new source
2016-04-28 22:46:39 +02:00
* Helper method to determine if a connects to b by its bank and angle, not location.
implement track save select nearby scenery
2015-06-07 17:02:43 +02:00
*/
move track design related functions to new source
2016-04-28 22:46:39 +02:00
int track_is_connected_by_shape(rct_map_element *a, rct_map_element *b)
implement track save select nearby scenery
2015-06-07 17:02:43 +02:00
{
move track design related functions to new source
2016-04-28 22:46:39 +02:00
int trackType, aBank, aAngle, bBank, bAngle;
implement track save select nearby scenery
2015-06-07 17:02:43 +02:00
move track design related functions to new source
2016-04-28 22:46:39 +02:00
trackType = a->properties.track.type;
aBank = gTrackDefinitions[trackType].bank_end;
aAngle = gTrackDefinitions[trackType].vangle_end;
aBank = track_get_actual_bank(a, aBank);
implement track save select nearby scenery
2015-06-07 17:02:43 +02:00
move track design related functions to new source
2016-04-28 22:46:39 +02:00
trackType = b->properties.track.type;
bBank = gTrackDefinitions[trackType].bank_start;
bAngle = gTrackDefinitions[trackType].vangle_start;
bBank = track_get_actual_bank(b, bBank);
implement track save select nearby scenery
2015-06-07 17:02:43 +02:00
move track design related functions to new source
2016-04-28 22:46:39 +02:00
return aBank == bBank && aAngle == bAngle;
implement track save select nearby scenery
2015-06-07 17:02:43 +02:00
}
add track block and possible ride configuration tables
2015-06-27 23:53:52 +02:00
const rct_preview_track *get_track_def_from_ride(rct_ride *ride, int trackType)
implement ride construction
2015-06-27 16:17:54 +02:00
{
return ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE) ?
add track block and possible ride configuration tables
2015-06-27 23:53:52 +02:00
FlatRideTrackBlocks[trackType] :
TrackBlocks[trackType];
implement ride construction
2015-06-27 16:17:54 +02:00
}
Implemented track block get next and previous. Minor refactor of ride functions as well.
2015-07-04 23:50:48 +02:00
const rct_track_coordinates *get_track_coord_from_ride(rct_ride *ride, int trackType){
return ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE) ?
&FlatTrackCoordinates[trackType] :
&TrackCoordinates[trackType];
}
add track block and possible ride configuration tables
2015-06-27 23:53:52 +02:00
const rct_preview_track *get_track_def_from_ride_index(int rideIndex, int trackType)
implement ride construction
2015-06-27 16:17:54 +02:00
{
Refactor rides to be only accessible with getters This changes how rides are accessed from macros to getter functions.
2016-01-22 15:38:52 +01:00
return get_track_def_from_ride(get_ride(rideIndex), trackType);
implement ride construction
2015-06-27 16:17:54 +02:00
}
prepare track place and remove game commands
2015-06-27 18:53:28 +02:00
implement track_add_station_element
2016-02-14 16:29:53 +01:00
static rct_map_element *find_station_element(int x, int y, int z, int direction, int rideIndex)
{
rct_map_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
do {
if (z != mapElement->base_height) continue;
if (map_element_get_type(mapElement) != MAP_ELEMENT_TYPE_TRACK) continue;
if (map_element_get_direction(mapElement) != direction) continue;
if (mapElement->properties.track.ride_index != rideIndex) continue;
if (!track_element_is_station(mapElement)) continue;
return mapElement;
} while (!map_element_is_last_for_tile(mapElement++));
return NULL;
}
static void ride_remove_station(rct_ride *ride, int x, int y, int z)
{
uint16 xy = (x >> 5) | ((y >> 5) << 8);
for (int i = 0; i < 4; i++) {
if (ride->station_starts[i] == xy && ride->station_heights[i] == z) {
ride->station_starts[i] = 0xFFFF;
ride->num_stations--;
break;
}
}
}
refactor two CALLPROC functions in track.c
2015-09-05 21:34:56 +02:00
/**
*
* rct2: 0x006C4D89
*/
implement track_add_station_element
2016-02-14 16:29:53 +01:00
static bool track_add_station_element(int x, int y, int z, int direction, int rideIndex, int flags)
refactor two CALLPROC functions in track.c
2015-09-05 21:34:56 +02:00
{
implement track_add_station_element
2016-02-14 16:29:53 +01:00
int stationX0 = x;
int stationY0 = y;
int stationX1 = x;
int stationY1 = y;
int stationLength = 1;
rct_ride *ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3)) {
if (ride->num_stations >= 4) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE;
implement track_add_station_element
2016-02-14 16:29:53 +01:00
return false;
}
if (flags & GAME_COMMAND_FLAG_APPLY) {
int stationIndex = -1;
for (int i = 0; i < 4; i++) {
if (ride->station_starts[i] == 0xFFFF) {
stationIndex = i;
break;
}
}
assert(stationIndex != -1);
ride->station_starts[stationIndex] = (x >> 5) | ((y >> 5) << 8);
ride->station_heights[stationIndex] = z;
ride->station_depart[stationIndex] = 1;
ride->station_length[stationIndex] = 0;
ride->num_stations++;
}
return true;
}
rct_map_element *stationElement;
// Search backwards for more station
x = stationX0;
y = stationY0;
do {
x -= TileDirectionDelta[direction].x;
y -= TileDirectionDelta[direction].y;
stationElement = find_station_element(x, y, z, direction, rideIndex);
if (stationElement != NULL) {
if (stationElement->properties.track.type == TRACK_ELEM_END_STATION) {
if (flags & GAME_COMMAND_FLAG_APPLY) {
ride_remove_station(ride, x, y, z);
}
}
stationX0 = x;
stationY0 = y;
stationLength++;
}
} while (stationElement != NULL);
// Search forwards for more station
x = stationX1;
y = stationY1;
do {
x += TileDirectionDelta[direction].x;
y += TileDirectionDelta[direction].y;
stationElement = find_station_element(x, y, z, direction, rideIndex);
if (stationElement != NULL) {
if (stationElement->properties.track.type == TRACK_ELEM_END_STATION) {
if (flags & GAME_COMMAND_FLAG_APPLY) {
ride_remove_station(ride, x, y, z);
}
}
stationX1 = x;
stationY1 = y;
stationLength++;
}
} while (stationElement != NULL);
if (stationX0 == stationX1 && stationY0 == stationY1 && ride->num_stations >= 4) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE;
implement track_add_station_element
2016-02-14 16:29:53 +01:00
return false;
}
Use a define for maximum station length
2016-05-07 09:15:22 +02:00
if (stationLength > MAX_STATION_PLATFORM_LENGTH) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_STATION_PLATFORM_TOO_LONG;
implement track_add_station_element
2016-02-14 16:29:53 +01:00
return false;
}
if (flags & GAME_COMMAND_FLAG_APPLY) {
x = stationX1;
y = stationY1;
bool finaliseStationDone;
do {
finaliseStationDone = true;
stationElement = find_station_element(x, y, z, direction, rideIndex);
if (stationElement != NULL) {
int targetTrackType;
if (x == stationX1 && y == stationY1) {
int stationIndex = -1;
for (int i = 0; i < 4; i++) {
if (ride->station_starts[i] == 0xFFFF) {
stationIndex = i;
break;
}
}
assert(stationIndex != -1);
uint16 xy = (x >> 5) | ((y >> 5) << 8);
ride->station_starts[stationIndex] = xy;
ride->station_heights[stationIndex] = z;
ride->station_depart[stationIndex] = 1;
ride->station_length[stationIndex] = stationLength;
ride->num_stations++;
targetTrackType = TRACK_ELEM_END_STATION;
} else if (x == stationX0 && y == stationY0) {
targetTrackType = TRACK_ELEM_BEGIN_STATION;
} else {
targetTrackType = TRACK_ELEM_MIDDLE_STATION;
}
stationElement->properties.track.type = targetTrackType;
map_invalidate_element(x, y, stationElement);
if (x != stationX0 || y != stationY0) {
x -= TileDirectionDelta[direction].x;
y -= TileDirectionDelta[direction].y;
finaliseStationDone = false;
}
}
} while (!finaliseStationDone);
}
return true;
refactor two CALLPROC functions in track.c
2015-09-05 21:34:56 +02:00
}
implement track_remove_station_element
2016-02-14 18:37:28 +01:00
/**
*
* rct2: 0x006C494B
*/
static bool track_remove_station_element(int x, int y, int z, int direction, int rideIndex, int flags)
{
int removeX = x;
int removeY = y;
int stationX0 = x;
int stationY0 = y;
int stationX1 = x;
int stationY1 = y;
Fix #2972. Station lengths now correctly calculated. Issue caused by counting number of stations off by one. This would cause the calculator to return 1 even on failure after a station element being removed.
2016-02-18 23:16:51 +01:00
int stationLength = 0;
implement track_remove_station_element
2016-02-14 18:37:28 +01:00
int byte_F441D1 = -1;
rct_ride *ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3)) {
rct_map_element *mapElement = map_get_track_element_at_with_direction_from_ride(x, y, z, direction, rideIndex);
if (mapElement != NULL) {
if (flags & GAME_COMMAND_FLAG_APPLY) {
ride_remove_station(ride, x, y, z);
}
}
return true;
}
rct_map_element *stationElement;
// Search backwards for more station
x = stationX0;
y = stationY0;
while ((stationElement = find_station_element(x, y, z, direction, rideIndex)) != NULL) {
if (stationElement->properties.track.type == TRACK_ELEM_END_STATION) {
if (flags & GAME_COMMAND_FLAG_APPLY) {
ride_remove_station(ride, x, y, z);
}
}
stationX0 = x;
stationY0 = y;
byte_F441D1++;
x -= TileDirectionDelta[direction].x;
y -= TileDirectionDelta[direction].y;
}
// Search forwards for more station
x = stationX1;
y = stationY1;
do {
x += TileDirectionDelta[direction].x;
y += TileDirectionDelta[direction].y;
stationElement = find_station_element(x, y, z, direction, rideIndex);
if (stationElement != NULL) {
if (stationElement->properties.track.type == TRACK_ELEM_END_STATION) {
if (flags & GAME_COMMAND_FLAG_APPLY) {
ride_remove_station(ride, x, y, z);
}
}
stationX1 = x;
stationY1 = y;
stationLength++;
}
} while (stationElement != NULL);
if (!(flags & GAME_COMMAND_FLAG_APPLY)) {
if ((removeX != stationX0 || removeY != stationY0) &&
(removeX != stationX1 || removeY != stationY1) &&
ride->num_stations >= 4
) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE;
implement track_remove_station_element
2016-02-14 18:37:28 +01:00
return false;
} else {
return true;
}
}
x = stationX1;
y = stationY1;
bool finaliseStationDone;
do {
finaliseStationDone = true;
if (x != removeX || y != removeY) {
stationElement = find_station_element(x, y, z, direction, rideIndex);
if (stationElement != NULL) {
int targetTrackType;
if (x == stationX1 && y == stationY1) {
loc_6C4BF5:;
int stationIndex = -1;
for (int i = 0; i < 4; i++) {
if (ride->station_starts[i] == 0xFFFF) {
stationIndex = i;
break;
}
}
assert(stationIndex != -1);
uint16 xy = (x >> 5) | ((y >> 5) << 8);
ride->station_starts[stationIndex] = xy;
ride->station_heights[stationIndex] = z;
ride->station_depart[stationIndex] = 1;
ride->station_length[stationIndex] = stationLength != 0 ? stationLength : byte_F441D1;
ride->num_stations++;
stationLength = 0;
targetTrackType = TRACK_ELEM_END_STATION;
} else {
if (x + TileDirectionDelta[direction].x == removeX &&
y + TileDirectionDelta[direction].y == removeY
) {
goto loc_6C4BF5;
} else {
if (x - TileDirectionDelta[direction].x == removeX &&
y - TileDirectionDelta[direction].y == removeY
) {
targetTrackType = TRACK_ELEM_BEGIN_STATION;
} else {
if (x == stationX0 && y == stationY0) {
targetTrackType = TRACK_ELEM_BEGIN_STATION;
} else {
targetTrackType = TRACK_ELEM_MIDDLE_STATION;
}
}
}
}
stationElement->properties.track.type = targetTrackType;
map_invalidate_element(x, y, stationElement);
}
}
if (x != stationX0 || y != stationY0) {
x -= TileDirectionDelta[direction].x;
y -= TileDirectionDelta[direction].y;
finaliseStationDone = false;
}
} while (!finaliseStationDone);
return true;
}
Implement track_place.
2015-07-02 21:07:44 +02:00
static money32 track_place(int rideIndex, int type, int originX, int originY, int originZ, int direction, int properties_1, int properties_2, int properties_3, int edx_flags, int flags)
{
Refactor rides to be only accessible with getters This changes how rides are accessed from macros to getter functions.
2016-01-22 15:38:52 +01:00
rct_ride *ride = get_ride(rideIndex);
Game commands' argument validation
2016-01-24 19:31:40 +01:00
if (ride == NULL)
{
log_warning("Invalid ride for track placement, rideIndex = %d", rideIndex);
return MONEY32_UNDEFINED;
}
Rename rct_ride_type to rct_ride_entry
2016-02-25 13:33:19 +01:00
rct_ride_entry *rideEntry = get_ride_entry(ride->subtype);
if (rideEntry == (rct_ride_entry *)0xFFFFFFFF || rideEntry == NULL)
Game commands' argument validation
2016-01-24 19:31:40 +01:00
{
log_warning("Invalid ride type for track placement, rideIndex = %d", rideIndex);
return MONEY32_UNDEFINED;
}
Implement track_place.
2015-07-02 21:07:44 +02:00
rct_map_element *mapElement;
integrate variables for command position and expenditure
2016-04-24 18:53:39 +02:00
gCommandExpenditureType = RCT_EXPENDITURE_TYPE_RIDE_CONSTRUCTION;
gCommandPosition.x = originX + 16;
gCommandPosition.y = originY + 16;
gCommandPosition.z = originZ;
more accurate last player action location
2016-01-25 05:00:31 +01:00
sint16 trackpieceZ = originZ;
Implement track_place.
2015-07-02 21:07:44 +02:00
direction &= 3;
RCT2_GLOBAL(0x00F441D5, uint32) = properties_1;
RCT2_GLOBAL(0x00F441D9, uint32) = properties_2;
RCT2_GLOBAL(0x00F441DD, uint32) = properties_3;
integrate ground flag variables
2016-05-17 21:51:11 +02:00
gTrackGroundFlags = 0;
Implement track_place.
2015-07-02 21:07:44 +02:00
uint64 enabledTrackPieces = 0;
add globals for researched things, cleanup
2016-05-10 01:00:59 +02:00
enabledTrackPieces |= rideEntry->enabledTrackPiecesB & gResearchedTrackTypesB[ride->type];
Implement track_place.
2015-07-02 21:07:44 +02:00
enabledTrackPieces <<= 32;
add globals for researched things, cleanup
2016-05-10 01:00:59 +02:00
enabledTrackPieces |= rideEntry->enabledTrackPiecesA & gResearchedTrackTypesA[ride->type];
Replace known addresses with constants
2016-01-11 01:50:03 +01:00
uint32 rideTypeFlags = RCT2_GLOBAL(RCT2_ADDRESS_RIDE_FLAGS + (ride->type * 8), uint32);
Implement track_place.
2015-07-02 21:07:44 +02:00
RCT2_GLOBAL(0x00F44068, uint32) = rideTypeFlags;
if ((ride->lifecycle_flags & RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK) && type == 1) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_NOT_ALLOWED_TO_MODIFY_STATION;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
if (!sub_68B044()) {
return MONEY32_UNDEFINED;
}
fix path placement for network
2015-07-27 04:15:02 +02:00
if (!(flags & GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED)) {
integrate game paused variable and refactor
2016-04-23 14:34:55 +02:00
if (game_is_paused() && !gCheatsBuildInPauseMode) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_CONSTRUCTION_NOT_POSSIBLE_WHILE_GAME_IS_PAUSED;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
}
potential fix or improvement to #2924: ride sync - Do not delete rides when sending map to clients. - Only do track related checks for track, not flat rides
2016-02-15 23:01:29 +01:00
if (rideTypeFlags & RIDE_TYPE_FLAG_FLAT_RIDE) {
RCT2_GLOBAL(0x00F44054, uint8*) = &RCT2_ADDRESS(0x0099AA94, uint8)[type * 16];
} else {
if (type == TRACK_ELEM_ON_RIDE_PHOTO) {
if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_RIDE_PHOTO) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_ONLY_ONE_ON_RIDE_PHOTO_PER_RIDE;
potential fix or improvement to #2924: ride sync - Do not delete rides when sending map to clients. - Only do track related checks for track, not flat rides
2016-02-15 23:01:29 +01:00
return MONEY32_UNDEFINED;
}
} else if (type == TRACK_ELEM_CABLE_LIFT_HILL) {
if (ride->lifecycle_flags & RIDE_LIFECYCLE_16) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_ONLY_ONE_CABLE_LIFT_HILL_PER_RIDE;
potential fix or improvement to #2924: ride sync - Do not delete rides when sending map to clients. - Only do track related checks for track, not flat rides
2016-02-15 23:01:29 +01:00
return MONEY32_UNDEFINED;
}
Implement track_place.
2015-07-02 21:07:44 +02:00
}
Chain lift cheat (#3818) * Fix conflict with disable plant aging cheat * Allow chain lift on any piece * Keep chain toggled while building * Ignore current chain lift state when cheat enabled * Update string ids to one not already used * Implement command for toggling cheat * Allow chain on steep tracks when cheat is enabled * Add checkbox for chain cheat * Fix spacing * Send cheat over network * Change label for checkbox * Replaced tabs with spaces
2016-06-07 23:08:38 +02:00
if ((edx_flags & (1 << 0)) && !(enabledTrackPieces & (1ULL << TRACK_LIFT_HILL_STEEP)) && !gCheatsEnableChainLiftOnAllTrack) {
potential fix or improvement to #2924: ride sync - Do not delete rides when sending map to clients. - Only do track related checks for track, not flat rides
2016-02-15 23:01:29 +01:00
if (RCT2_ADDRESS(0x0099423C, uint16)[type] & 0x400) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_TOO_STEEP_FOR_LIFT_HILL;
potential fix or improvement to #2924: ride sync - Do not delete rides when sending map to clients. - Only do track related checks for track, not flat rides
2016-02-15 23:01:29 +01:00
return MONEY32_UNDEFINED;
}
Implement track_place.
2015-07-02 21:07:44 +02:00
}
RCT2_GLOBAL(0x00F44054, uint8*) = &RCT2_ADDRESS(0x00999A94, uint8)[type * 16];
}
money32 cost = 0;
const rct_preview_track *trackBlock = get_track_def_from_ride(ride, type);
Fix supports error appearing when building outside of owned land This was caused by ride_construction_toolupdate_construct() pointlessly trying to fix the "building outside owned land" error by increasing the Z.
2015-10-27 23:11:30 +01:00
// First check if any of the track pieces are outside the park
for (; trackBlock->index != 0xFF; trackBlock++) {
int x, y, z, offsetX, offsetY;
switch (direction) {
case 0:
offsetX = trackBlock->x;
offsetY = trackBlock->y;
break;
case 1:
offsetX = trackBlock->y;
offsetY = -trackBlock->x;
break;
case 2:
offsetX = -trackBlock->x;
offsetY = -trackBlock->y;
break;
case 3:
offsetX = -trackBlock->y;
offsetY = trackBlock->x;
break;
}
x = originX + offsetX;
y = originY + offsetY;
z = originZ + trackBlock->z;
if (!map_is_location_owned(x, y, z) && !gCheatsSandboxMode) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_LAND_NOT_OWNED_BY_PARK;
Fix supports error appearing when building outside of owned land This was caused by ride_construction_toolupdate_construct() pointlessly trying to fix the "building outside owned land" error by increasing the Z.
2015-10-27 23:11:30 +01:00
return MONEY32_UNDEFINED;
}
}
use larger integers in ride/track.c
2015-12-06 18:54:48 +01:00
Rename hmm variable to something more descriptive
2015-11-08 22:30:51 +01:00
uint16 *trackFlags = (rideTypeFlags & RIDE_TYPE_FLAG_FLAT_RIDE) ?
RCT2_ADDRESS(0x0099443C, uint16) :
RCT2_ADDRESS(0x0099423C, uint16);
if (trackFlags[type] & 0x100) {
Fix "land not owned" errors being overridden by "can't construct here" I'm not entirely sure what the "hmm" check is about, but it caused track_place() to return early when called from window_ride_construction_construct(), so I moved up the owned land check to give it a higher priority.
2015-10-28 10:50:12 +01:00
if ((originZ & 0x0F) != 8) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = 954;
Fix "land not owned" errors being overridden by "can't construct here" I'm not entirely sure what the "hmm" check is about, but it caused track_place() to return early when called from window_ride_construction_construct(), so I moved up the owned land check to give it a higher priority.
2015-10-28 10:50:12 +01:00
return MONEY32_UNDEFINED;
}
} else {
if ((originZ & 0x0F) != 0) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = 954;
Fix "land not owned" errors being overridden by "can't construct here" I'm not entirely sure what the "hmm" check is about, but it caused track_place() to return early when called from window_ride_construction_construct(), so I moved up the owned land check to give it a higher priority.
2015-10-28 10:50:12 +01:00
return MONEY32_UNDEFINED;
}
}
Fix supports error appearing when building outside of owned land This was caused by ride_construction_toolupdate_construct() pointlessly trying to fix the "building outside owned land" error by increasing the Z.
2015-10-27 23:11:30 +01:00
// If that is not the case, then perform the remaining checks
trackBlock = get_track_def_from_ride(ride, type);
Implement track_place.
2015-07-02 21:07:44 +02:00
for (; trackBlock->index != 0xFF; trackBlock++, RCT2_GLOBAL(0x00F44054, uint8*)++) {
int x, y, z, offsetX, offsetY;
int bl = trackBlock->var_08;
int bh;
switch (direction) {
case 0:
offsetX = trackBlock->x;
offsetY = trackBlock->y;
break;
case 1:
offsetX = trackBlock->y;
offsetY = -trackBlock->x;
bl = rol8(bl, 1);
bh = bl;
bh = ror8(bh, 4);
bl &= 0xEE;
bh &= 0x11;
bl |= bh;
break;
case 2:
offsetX = -trackBlock->x;
offsetY = -trackBlock->y;
bl = rol8(bl, 2);
bh = bl;
bh = ror8(bh, 4);
bl &= 0xCC;
bh &= 0x33;
bl |= bh;
break;
case 3:
offsetX = -trackBlock->y;
offsetY = trackBlock->x;
bl = rol8(bl, 3);
Fix track bugs. Fixed issue with ride demolishing where only the first tile of a ride would get demolished causing issues when the ride entries were removed. Fixed issue with rotation 3 track pieces where invalid memory would be accessed. Fixes #1506 Fixes #1556
2015-07-06 19:21:42 +02:00
bh = bl;
Implement track_place.
2015-07-02 21:07:44 +02:00
bh = ror8(bh, 4);
bl &= 0x88;
bh &= 0x77;
bl |= bh;
break;
}
x = originX + offsetX;
y = originY + offsetY;
z = originZ + trackBlock->z;
more accurate last player action location
2016-01-25 05:00:31 +01:00
trackpieceZ = z;
Implement track_place.
2015-07-02 21:07:44 +02:00
if (z < 16) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_TOO_LOW;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
int baseZ = (originZ + trackBlock->z) / 8;
int clearanceZ = trackBlock->var_07;
Extract new struct
2016-04-03 14:53:17 +02:00
if (trackBlock->var_09 & (1 << 2) && RideData5[ride->type].clearance_height > 24) {
Implement track_place.
2015-07-02 21:07:44 +02:00
clearanceZ += 24;
}
else{
Extract new struct
2016-04-03 14:53:17 +02:00
clearanceZ += RideData5[ride->type].clearance_height;
Implement track_place.
2015-07-02 21:07:44 +02:00
}
clearanceZ = (clearanceZ / 8) + baseZ;
if (clearanceZ >= 255) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_TOO_HIGH;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
_currentTrackEndX = x;
_currentTrackEndY = y;
fix game_command_create_ride for network
2015-07-24 01:22:03 +02:00
if (!gCheatsDisableClearanceChecks || flags & GAME_COMMAND_FLAG_GHOST){
Refactor clear funcs
2016-02-13 22:01:36 +01:00
if (!map_can_construct_with_clear_at(x, y, baseZ, clearanceZ, &map_place_non_scenery_clear_func, bl, flags, &cost))
Added zero clearance to track placement. Due to how track placement works you need to hold down shift when placing the track. Ignore the ghost placement. Also disable support limits is enabled.
2015-07-03 23:58:37 +02:00
return MONEY32_UNDEFINED;
Implement track_place.
2015-07-02 21:07:44 +02:00
}
//6c53dc
fix removing of fences for normal tracks Building track and track designs did not use correct flag for ghosts therefore always attempting to remove fences and the removing of intersecting fences also did not work correctly. Fix both issues.
2016-04-03 00:51:12 +02:00
if ((flags & GAME_COMMAND_FLAG_APPLY) && !(flags & GAME_COMMAND_FLAG_GHOST)) {
Implement track_place.
2015-07-02 21:07:44 +02:00
footpath_remove_litter(x, y, z);
if (rideTypeFlags & RIDE_TYPE_FLAG_18) {
implement map_remove_walls_at
2015-07-06 21:29:36 +02:00
map_remove_walls_at(x, y, baseZ * 8, clearanceZ * 8);
fix removing of fences for normal tracks Building track and track designs did not use correct flag for ghosts therefore always attempting to remove fences and the removing of intersecting fences also did not work correctly. Fix both issues.
2016-04-03 00:51:12 +02:00
} else {
// Remove walls in the directions this track intersects
uint8 intersectingDirections = *RCT2_GLOBAL(0x00F44054, uint8*);
intersectingDirections ^= 0x0F;
for (int i = 0; i < 4; i++) {
if (intersectingDirections & (1 << i)) {
map_remove_intersecting_walls(x, y, baseZ, clearanceZ, i);
}
Implement track_place.
2015-07-02 21:07:44 +02:00
}
}
}
integrate ground flag variables
2016-05-17 21:51:11 +02:00
bh = gMapGroundFlags & (ELEMENT_IS_1 | ELEMENT_IS_UNDERGROUND);
if (gTrackGroundFlags != 0 && (gTrackGroundFlags & bh) == 0) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_CANT_BUILD_PARTLY_ABOVE_AND_PARTLY_BELOW_GROUND;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
integrate ground flag variables
2016-05-17 21:51:11 +02:00
gTrackGroundFlags = bh;
Implement track_place.
2015-07-02 21:07:44 +02:00
if (rideTypeFlags & RIDE_TYPE_FLAG_FLAT_RIDE) {
if (RCT2_ADDRESS(0x0099443C, uint16)[type] & 0x200) {
integrate ground flag variables
2016-05-17 21:51:11 +02:00
if (gTrackGroundFlags & TRACK_ELEMENT_LOCATION_IS_UNDERGROUND) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_ABOVE_GROUND;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
}
}
else {
if (RCT2_ADDRESS(0x0099423C, uint16)[type] & 0x200) {
integrate ground flag variables
2016-05-17 21:51:11 +02:00
if (gTrackGroundFlags & TRACK_ELEMENT_LOCATION_IS_UNDERGROUND) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_ABOVE_GROUND;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
}
}
if (rideTypeFlags & RIDE_TYPE_FLAG_FLAT_RIDE) {
if (RCT2_ADDRESS(0x0099443C, uint16)[type] & 1) {
integrate ground flag variables
2016-05-17 21:51:11 +02:00
if (!(gMapGroundFlags & ELEMENT_IS_UNDERWATER)) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_UNDERWATER;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
}
}
else {
if (RCT2_ADDRESS(0x0099423C, uint16)[type] & 1) {
integrate ground flag variables
2016-05-17 21:51:11 +02:00
if (gMapGroundFlags & ELEMENT_IS_UNDERWATER) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_UNDERWATER;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
}
}
integrate ground flag variables
2016-05-17 21:51:11 +02:00
if (gMapGroundFlags & ELEMENT_IS_UNDERWATER) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_RIDE_CANT_BUILD_THIS_UNDERWATER;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
integrate more variables
2016-05-02 20:32:09 +02:00
if ((rideTypeFlags & RIDE_TYPE_FLAG_6) && !(byte_9D8150 & 1)) {
Implement track_place.
2015-07-02 21:07:44 +02:00
mapElement = map_get_surface_element_at(x / 32, y / 32);
uint8 water_height = 2 * (mapElement->properties.surface.terrain & MAP_ELEMENT_WATER_HEIGHT_MASK);
if (water_height == 0) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_ON_WATER;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
if (water_height != baseZ) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_ON_WATER;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
water_height -= 2;
if (water_height == mapElement->base_height) {
bh = mapElement->properties.surface.slope & 0x0F;
if (bh == 7 || bh == 11 || bh == 13 || bh == 14) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_ON_WATER;
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
}
}
int entranceDirections;
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
entranceDirections = RCT2_ADDRESS(0x0099CA64, uint8)[type * 16];
}
else {
entranceDirections = RCT2_ADDRESS(0x0099BA64, uint8)[type * 16];
}
if ((entranceDirections & 0x10) && trackBlock->index == 0) {
implement track_add_station_element
2016-02-14 16:29:53 +01:00
if (!track_add_station_element(x, y, baseZ, direction, rideIndex, 0)) {
Implement track_place.
2015-07-02 21:07:44 +02:00
return MONEY32_UNDEFINED;
}
}
//6c55be
if (entranceDirections & 0x20) {
entranceDirections &= 0x0F;
if (entranceDirections != 0) {
fix game_command_create_ride for network
2015-07-24 01:22:03 +02:00
if (!(flags & GAME_COMMAND_FLAG_APPLY) && !(flags & GAME_COMMAND_FLAG_GHOST)) {
Implement track_place.
2015-07-02 21:07:44 +02:00
uint8 _bl = entranceDirections;
for (int dl = bitscanforward(_bl); dl != -1; dl = bitscanforward(_bl)){
_bl &= ~(1 << dl);
int temp_x = x, temp_y = y;
int temp_direction = (direction + dl) & 3;
remove old usages of 0x00993CCC and 0x00F441D3
2016-02-20 16:50:05 +01:00
temp_x += TileDirectionDelta[temp_direction].x;
temp_y += TileDirectionDelta[temp_direction].y;
Implement track_place.
2015-07-02 21:07:44 +02:00
temp_direction ^= (1 << 1);
map_remove_intersecting_walls(temp_x, temp_y, baseZ, clearanceZ, temp_direction & 3);
}
}
}
}
//6c5648 12 push
mapElement = map_get_surface_element_at(x / 32, y / 32);
Added zero clearance to track placement. Due to how track placement works you need to hold down shift when placing the track. Ignore the ghost placement. Also disable support limits is enabled.
2015-07-03 23:58:37 +02:00
if (!gCheatsDisableSupportLimits){
int ride_height = clearanceZ - mapElement->base_height;
if (ride_height >= 0) {
int maxHeight = rideEntry->max_height;
if (maxHeight == 0) {
Extract new struct
2016-04-03 14:53:17 +02:00
maxHeight = RideData5[ride->type].max_height;
Added zero clearance to track placement. Due to how track placement works you need to hold down shift when placing the track. Ignore the ghost placement. Also disable support limits is enabled.
2015-07-03 23:58:37 +02:00
}
ride_height /= 2;
integrate more variables
2016-05-02 20:32:09 +02:00
if (ride_height > maxHeight && !(byte_9D8150 & 1)) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_TOO_HIGH_FOR_SUPPORTS;
Added zero clearance to track placement. Due to how track placement works you need to hold down shift when placing the track. Ignore the ghost placement. Also disable support limits is enabled.
2015-07-03 23:58:37 +02:00
return MONEY32_UNDEFINED;
}
Implement track_place.
2015-07-02 21:07:44 +02:00
}
}
int support_height = baseZ - mapElement->base_height;
if (support_height < 0) {
support_height = 10;
}
Include struct at `0x0097DD78`
2016-04-03 13:41:00 +02:00
cost += ((support_height / 2) * RideTrackCosts[ride->type].support_price) * 5;
Fix a miscalculation on the track cost (Fixes #3074)
2016-03-03 21:57:44 +01:00
Implement track_place.
2015-07-02 21:07:44 +02:00
//6c56d3
if (!(flags & GAME_COMMAND_FLAG_APPLY))
continue;
Rename sub_6B59C6() to invalidate_test_results()
2015-07-17 13:49:36 +02:00
invalidate_test_results(rideIndex);
Implement track_place.
2015-07-02 21:07:44 +02:00
switch (type){
case TRACK_ELEM_ON_RIDE_PHOTO:
ride->lifecycle_flags |= RIDE_LIFECYCLE_ON_RIDE_PHOTO;
break;
case TRACK_ELEM_CABLE_LIFT_HILL:
if (trackBlock->index != 0)
break;
ride->lifecycle_flags |= RIDE_LIFECYCLE_16;
implement ride_create_cable_lift
2015-09-12 19:17:25 +02:00
ride->cable_lift_x = x;
ride->cable_lift_y = y;
ride->cable_lift_z = baseZ;
Implement track_place.
2015-07-02 21:07:44 +02:00
break;
case 0xD8:
ride->num_block_brakes++;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_OPERATING;
ride->mode = RIDE_MODE_CONTINUOUS_CIRCUIT_BLOCK_SECTIONED;
if (ride->type == RIDE_TYPE_LIM_LAUNCHED_ROLLER_COASTER)
ride->mode = RIDE_MODE_POWERED_LAUNCH_BLOCK_SECTIONED;
break;
}
if (trackBlock->index == 0){
switch (type){
case TRACK_ELEM_25_DEG_UP_TO_FLAT:
case TRACK_ELEM_60_DEG_UP_TO_FLAT:
case TRACK_ELEM_DIAG_25_DEG_UP_TO_FLAT:
case TRACK_ELEM_DIAG_60_DEG_UP_TO_FLAT:
if (!(edx_flags & 1))
break;
//Fall Through
case TRACK_ELEM_CABLE_LIFT_HILL:
ride->num_block_brakes++;
break;
}
}
entranceDirections = 0;
if (ride->overall_view != 0xFFFF){
fix game_command_create_ride for network
2015-07-24 01:22:03 +02:00
if (!(flags & GAME_COMMAND_FLAG_5)){
Implement track_place.
2015-07-02 21:07:44 +02:00
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
entranceDirections = RCT2_ADDRESS(0x0099CA64, uint8)[type * 16];
}
else {
entranceDirections = RCT2_ADDRESS(0x0099BA64, uint8)[type * 16];
}
}
}
if (entranceDirections & (1 << 4) || ride->overall_view == 0xFFFF){
ride->overall_view = (x >> 5) | (y << 3);
}
mapElement = map_element_insert(x / 32, y / 32, baseZ, bl & 0xF);
Minor fixes
2016-02-26 20:49:01 +01:00
assert(mapElement != NULL);
Implement track_place.
2015-07-02 21:07:44 +02:00
mapElement->clearance_height = clearanceZ;
uint8 map_type = direction;
map_type |= MAP_ELEMENT_TYPE_TRACK;
if (edx_flags & 1){
map_type |= (1 << 7);
}
mapElement->type = map_type;
mapElement->properties.track.sequence = trackBlock->index;
mapElement->properties.track.ride_index = rideIndex;
mapElement->properties.track.type = type;
mapElement->properties.track.colour = 0;
fix game_command_create_ride for network
2015-07-24 01:22:03 +02:00
if (flags & GAME_COMMAND_FLAG_GHOST){
Implement track_place.
2015-07-02 21:07:44 +02:00
mapElement->flags |= MAP_ELEMENT_FLAG_GHOST;
}
switch (type) {
case TRACK_ELEM_WATERFALL:
Fix animated track elements.
2015-07-03 22:40:26 +02:00
map_animation_create(MAP_ANIMATION_TYPE_TRACK_WATERFALL, x, y, mapElement->base_height);
Implement track_place.
2015-07-02 21:07:44 +02:00
break;
case TRACK_ELEM_RAPIDS:
Fix animated track elements.
2015-07-03 22:40:26 +02:00
map_animation_create(MAP_ANIMATION_TYPE_TRACK_RAPIDS, x, y, mapElement->base_height);
Implement track_place.
2015-07-02 21:07:44 +02:00
break;
case TRACK_ELEM_WHIRLPOOL:
Fix animated track elements.
2015-07-03 22:40:26 +02:00
map_animation_create(MAP_ANIMATION_TYPE_TRACK_WHIRLPOOL, x, y, mapElement->base_height);
Implement track_place.
2015-07-02 21:07:44 +02:00
break;
case TRACK_ELEM_SPINNING_TUNNEL:
Fix animated track elements.
2015-07-03 22:40:26 +02:00
map_animation_create(MAP_ANIMATION_TYPE_TRACK_SPINNINGTUNNEL, x, y, mapElement->base_height);
Implement track_place.
2015-07-02 21:07:44 +02:00
break;
}
if (type == TRACK_ELEM_BRAKES) {
mapElement->properties.track.sequence = (properties_1 >> 1) << 4;
}
else {
mapElement->properties.track.colour = properties_3 << 4;
}
uint8 colour = properties_2;
if (edx_flags & (1 << 1)){
colour |= (1 << 2);
}
mapElement->properties.track.colour |= colour;
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
entranceDirections = RCT2_ADDRESS(0x0099CA64, uint8)[type * 16];
}
else {
entranceDirections = RCT2_ADDRESS(0x0099BA64, uint8)[type * 16];
}
refactor two CALLPROC functions in track.c
2015-09-05 21:34:56 +02:00
if (entranceDirections & (1 << 4)) {
if (trackBlock->index == 0) {
implement track_add_station_element
2016-02-14 16:29:53 +01:00
track_add_station_element(x, y, baseZ, direction, rideIndex, GAME_COMMAND_FLAG_APPLY);
Implement track_place.
2015-07-02 21:07:44 +02:00
}
sub_6CB945(rideIndex);
ride_update_max_vehicles(rideIndex);
}
if (rideTypeFlags & RIDE_TYPE_FLAG_6){
rct_map_element* surfaceElement = map_get_surface_element_at(x / 32, y / 32);
surfaceElement->type |= (1 << 6);
mapElement = surfaceElement;
}
fix #1736
2015-08-05 22:36:58 +02:00
if (!gCheatsDisableClearanceChecks || !(flags & (1 << 6))) {
footpath_connect_edges(x, y, mapElement, flags);
}
Implement track_place.
2015-07-02 21:07:44 +02:00
map_invalidate_tile_full(x, y);
}
integrate gGameCommandNestLevel
2016-05-17 22:47:14 +02:00
if (gGameCommandNestLevel == 1) {
more accurate last player action location
2016-01-25 05:00:31 +01:00
rct_xyz16 coord;
coord.x = originX + 16;
coord.y = originY + 16;
coord.z = trackpieceZ;
network_set_player_last_action_coord(network_get_player_index(game_command_playerid), coord);
}
Include struct at `0x0097DD78`
2016-04-03 13:41:00 +02:00
money32 price = RideTrackCosts[ride->type].track_price;
Implement track_place.
2015-07-02 21:07:44 +02:00
price *= (rideTypeFlags & RIDE_TYPE_FLAG_FLAT_RIDE) ?
RCT2_ADDRESS(0x0099DE34, money32)[type] :
RCT2_ADDRESS(0x0099DA34, money32)[type];
price >>= 16;
Make code more clean. Removed an unnecessary "else" code and a unnecessary division with the variable cost.
2016-03-04 00:40:44 +01:00
price = cost + ((price / 2) * 10);
Implement track_place.
2015-07-02 21:07:44 +02:00
add global macro: gParkFlags
2016-04-23 01:51:22 +02:00
if (gParkFlags & PARK_FLAGS_NO_MONEY) {
Implement track_place.
2015-07-02 21:07:44 +02:00
return 0;
}
else {
return price;
}
}
Memory access fixes
2015-09-12 00:16:05 +02:00
prepare track place and remove game commands
2015-06-27 18:53:28 +02:00
/**
*
* rct2: 0x006C511D
*/
void game_command_place_track(int *eax, int *ebx, int *ecx, int *edx, int *esi, int *edi, int *ebp)
{
Implement track_place.
2015-07-02 21:07:44 +02:00
*ebx = track_place(
*edx & 0xFF,
(*edx >> 8) & 0xFF,
fix #3266: too high message given instead of too low caused by Z parameter not being correctly converted to a signed int 16.
2016-04-09 13:52:12 +02:00
(sint16)(*eax & 0xFFFF),
(sint16)(*ecx & 0xFFFF),
(sint16)(*edi & 0xFFFF),
Implement track_place.
2015-07-02 21:07:44 +02:00
(*ebx >> 8) & 0xFF,
(*edi >> 16) & 0xFF,
(*edi >> 24) & 0x0F,
(*edi >> 28) & 0x0F,
(*edx >> 16),
*ebx & 0xFF
);
prepare track place and remove game commands
2015-06-27 18:53:28 +02:00
}
Implemented track_remove
2015-07-05 12:50:43 +02:00
money32 track_remove(uint8 type, uint8 sequence, sint16 originX, sint16 originY, sint16 originZ, uint8 rotation, uint8 flags){
integrate variables for command position and expenditure
2016-04-24 18:53:39 +02:00
gCommandExpenditureType = RCT_EXPENDITURE_TYPE_RIDE_CONSTRUCTION;
gCommandPosition.x = originX + 16;
gCommandPosition.y = originY + 16;
gCommandPosition.z = originZ;
more accurate last player action location
2016-01-25 05:00:31 +01:00
sint16 trackpieceZ = originZ;
Implemented track_remove
2015-07-05 12:50:43 +02:00
RCT2_GLOBAL(0x00F440E1, uint8) = sequence;
switch (type){
case TRACK_ELEM_BEGIN_STATION:
case TRACK_ELEM_MIDDLE_STATION:
type = TRACK_ELEM_END_STATION;
break;
}
integrate game paused variable and refactor
2016-04-23 14:34:55 +02:00
if (!(flags & (1 << 3)) && game_is_paused() && !gCheatsBuildInPauseMode){
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_CONSTRUCTION_NOT_POSSIBLE_WHILE_GAME_IS_PAUSED;
Implemented track_remove
2015-07-05 12:50:43 +02:00
return MONEY32_UNDEFINED;
}
uint8 found = 0;
rct_map_element* mapElement = map_get_first_element_at(originX / 32, originY / 32);
Game commands hardening
2016-01-03 00:49:08 +01:00
if (mapElement == NULL)
{
log_warning("Invalid coordinates for track removal. x = %d, y = %d", originX, originY);
return MONEY32_UNDEFINED;
}
Implemented track_remove
2015-07-05 12:50:43 +02:00
do{
if (mapElement->base_height * 8 != originZ)
continue;
if (map_element_get_type(mapElement) != MAP_ELEMENT_TYPE_TRACK)
continue;
if ((mapElement->type & MAP_ELEMENT_DIRECTION_MASK) != rotation)
continue;
if ((mapElement->properties.track.sequence & 0xF) != sequence)
continue;
// Probably should add a check for ghost here as well!
uint8 track_type = mapElement->properties.track.type;
switch (track_type){
case TRACK_ELEM_BEGIN_STATION:
case TRACK_ELEM_MIDDLE_STATION:
track_type = TRACK_ELEM_END_STATION;
break;
}
if (track_type != type)
continue;
found = 1;
break;
} while (!map_element_is_last_for_tile(mapElement++));
if (!found){
return MONEY32_UNDEFINED;
}
if (mapElement->flags & (1 << 6)){
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_YOU_ARE_NOT_ALLOWED_TO_REMOVE_THIS_SECTION;
Implemented track_remove
2015-07-05 12:50:43 +02:00
return MONEY32_UNDEFINED;
}
uint8 rideIndex = mapElement->properties.track.ride_index;
type = mapElement->properties.track.type;
RCT2_GLOBAL(0x00F44139, uint8) = type;
RCT2_GLOBAL(0x00F44138, uint8) = rideIndex;
RCT2_GLOBAL(0x00F4414C, uint8) = mapElement->type;
Refactor rides to be only accessible with getters This changes how rides are accessed from macros to getter functions.
2016-01-22 15:38:52 +01:00
rct_ride* ride = get_ride(rideIndex);
Implemented track_remove
2015-07-05 12:50:43 +02:00
const rct_preview_track* trackBlock = get_track_def_from_ride(ride, type);
trackBlock += mapElement->properties.track.sequence & 0xF;
Fix bug in track remove. Fixes #1552
2015-07-05 21:57:14 +02:00
uint8 originDirection = mapElement->type & MAP_ELEMENT_DIRECTION_MASK;
switch (originDirection){
Implemented track_remove
2015-07-05 12:50:43 +02:00
case 0:
originX -= trackBlock->x;
originY -= trackBlock->y;
break;
case 1:
originX -= trackBlock->y;
originY += trackBlock->x;
break;
case 2:
originX += trackBlock->x;
originY += trackBlock->y;
break;
case 3:
originX += trackBlock->y;
originY -= trackBlock->x;
break;
}
originZ -= trackBlock->z;
money32 cost = 0;
trackBlock = get_track_def_from_ride(ride, type);
for (; trackBlock->index != 255; trackBlock++){
sint16 x = originX, y = originY, z = originZ;
Fix bug in track remove. Fixes #1552
2015-07-05 21:57:14 +02:00
switch (originDirection){
Implemented track_remove
2015-07-05 12:50:43 +02:00
case 0:
x += trackBlock->x;
y += trackBlock->y;
break;
case 1:
x += trackBlock->y;
y -= trackBlock->x;
break;
case 2:
x -= trackBlock->x;
y -= trackBlock->y;
break;
case 3:
x -= trackBlock->y;
y += trackBlock->x;
break;
}
z += trackBlock->z;
map_invalidate_tile_full(x, y);
RCT2_GLOBAL(0x00F441C4, sint16) = x;
RCT2_GLOBAL(0x00F441C6, sint16) = y;
more accurate last player action location
2016-01-25 05:00:31 +01:00
trackpieceZ = z;
Implemented track_remove
2015-07-05 12:50:43 +02:00
found = 0;
mapElement = map_get_first_element_at(x / 32, y / 32);
do{
if (mapElement->base_height != z / 8)
continue;
if (map_element_get_type(mapElement) != MAP_ELEMENT_TYPE_TRACK)
continue;
if ((mapElement->type & MAP_ELEMENT_DIRECTION_MASK) != rotation)
continue;
if ((mapElement->properties.track.sequence & 0xF) != trackBlock->index)
continue;
if (mapElement->properties.track.type != type)
continue;
found = 1;
break;
} while (!map_element_is_last_for_tile(mapElement++));
if (!found){
log_error("Track map element part not found!");
return MONEY32_UNDEFINED;
}
int entranceDirections;
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
entranceDirections = RCT2_ADDRESS(0x0099CA64, uint8)[type * 16];
}
else {
entranceDirections = RCT2_ADDRESS(0x0099BA64, uint8)[type * 16];
}
Fix multiple station platforms. Small mistake was causing multiple station platforms to not be properly deleted from a rct_ride. Fixes #1566
2015-07-08 19:46:32 +02:00
if (entranceDirections & (1 << 4) && ((mapElement->properties.track.sequence & 0xF) == 0)){
implement track_remove_station_element
2016-02-14 18:37:28 +01:00
if (!track_remove_station_element(x, y, z / 8, rotation, rideIndex, 0)) {
Implemented track_remove
2015-07-05 12:50:43 +02:00
return MONEY32_UNDEFINED;
}
}
rct_map_element* surfaceElement = map_get_surface_element_at(x / 32, y / 32);
if (surfaceElement == NULL){
return MONEY32_UNDEFINED;
}
Fix support cost multiplier underground. Fixes #1651
2015-07-20 18:21:32 +02:00
sint8 support_height = mapElement->base_height - surfaceElement->base_height;
Implemented track_remove
2015-07-05 12:50:43 +02:00
if (support_height < 0){
support_height = 10;
}
Include struct at `0x0097DD78`
2016-04-03 13:41:00 +02:00
cost += (support_height / 2) * RideTrackCosts[ride->type].support_price;
Implemented track_remove
2015-07-05 12:50:43 +02:00
if (!(flags & GAME_COMMAND_FLAG_APPLY))
continue;
Fix multiple station platforms. Small mistake was causing multiple station platforms to not be properly deleted from a rct_ride. Fixes #1566
2015-07-08 19:46:32 +02:00
if (entranceDirections & (1 << 4) && ((mapElement->properties.track.sequence & 0xF) == 0)){
implement track_remove_station_element
2016-02-14 18:37:28 +01:00
if (!track_remove_station_element(x, y, z / 8, rotation, rideIndex, GAME_COMMAND_FLAG_APPLY)) {
Implemented track_remove
2015-07-05 12:50:43 +02:00
return MONEY32_UNDEFINED;
}
}
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_6)){
surfaceElement->type &= ~(1 << 6);
}
Rename sub_6B59C6() to invalidate_test_results()
2015-07-17 13:49:36 +02:00
invalidate_test_results(rideIndex);
integrate queue chain and refactor
2016-05-17 22:29:05 +02:00
footpath_queue_chain_reset();
fix #1736
2015-08-05 22:36:58 +02:00
if (!gCheatsDisableClearanceChecks || !(mapElement->flags & MAP_ELEMENT_FLAG_GHOST)) {
footpath_remove_edges_at(x, y, mapElement);
}
Implemented track_remove
2015-07-05 12:50:43 +02:00
map_element_remove(mapElement);
sub_6CB945(rideIndex);
if (!(flags & (1 << 6))){
ride_update_max_vehicles(rideIndex);
}
}
if (flags & GAME_COMMAND_FLAG_APPLY){
switch (type){
case TRACK_ELEM_ON_RIDE_PHOTO:
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_ON_RIDE_PHOTO;
break;
case TRACK_ELEM_CABLE_LIFT_HILL:
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_16;
break;
case 216:
ride->num_block_brakes--;
if (ride->num_block_brakes == 0){
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_OPERATING;
ride->mode = RIDE_MODE_CONTINUOUS_CIRCUIT;
if (ride->type == RIDE_TYPE_LIM_LAUNCHED_ROLLER_COASTER){
ride->mode = RIDE_MODE_POWERED_LAUNCH;
}
}
break;
}
switch (type){
case TRACK_ELEM_25_DEG_UP_TO_FLAT:
case TRACK_ELEM_60_DEG_UP_TO_FLAT:
case TRACK_ELEM_DIAG_25_DEG_UP_TO_FLAT:
case TRACK_ELEM_DIAG_60_DEG_UP_TO_FLAT:
if (!(RCT2_GLOBAL(0x00F4414C, uint8) & (1 << 7)))
break;
// Fall through
case TRACK_ELEM_CABLE_LIFT_HILL:
ride->num_block_brakes--;
break;
}
}
Include struct at `0x0097DD78`
2016-04-03 13:41:00 +02:00
money32 price = RideTrackCosts[ride->type].track_price;
Implemented track_remove
2015-07-05 12:50:43 +02:00
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
Fix incorrect refund price for tracks. Fixes #1548.
2015-07-05 16:22:56 +02:00
price *= RCT2_ADDRESS(0x0099DE34, money32)[type];
Implemented track_remove
2015-07-05 12:50:43 +02:00
}
else {
Fix incorrect refund price for tracks. Fixes #1548.
2015-07-05 16:22:56 +02:00
price *= RCT2_ADDRESS(0x0099DA34, money32)[type];
Implemented track_remove
2015-07-05 12:50:43 +02:00
}
price >>= 16;
price = (price + cost) / 2;
if (ride->lifecycle_flags & RIDE_LIFECYCLE_EVER_BEEN_OPENED)
price *= -7;
else
price *= -10;
integrate gGameCommandNestLevel
2016-05-17 22:47:14 +02:00
if (gGameCommandNestLevel == 1) {
more accurate last player action location
2016-01-25 05:00:31 +01:00
rct_xyz16 coord;
coord.x = originX + 16;
coord.y = originY + 16;
coord.z = trackpieceZ;
network_set_player_last_action_coord(network_get_player_index(game_command_playerid), coord);
}
add global macro: gParkFlags
2016-04-23 01:51:22 +02:00
if (gParkFlags & PARK_FLAGS_NO_MONEY)
Implemented track_remove
2015-07-05 12:50:43 +02:00
return 0;
else
return price;
}
prepare track place and remove game commands
2015-06-27 18:53:28 +02:00
/**
*
* rct2: 0x006C5B69
*/
void game_command_remove_track(int *eax, int *ebx, int *ecx, int *edx, int *esi, int *edi, int *ebp)
{
Implemented track_remove
2015-07-05 12:50:43 +02:00
*ebx = track_remove(
*edx & 0xFF,
(*edx >> 8) & 0xFF,
*eax & 0xFFFF,
*ecx & 0xFFFF,
*edi & 0xFFFF,
(*ebx >> 8) & 0xFF,
*ebx & 0xFF
);
return;
fix setting brakes speed on current track and implement game command
2015-06-28 12:44:34 +02:00
}
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
uint8 maze_element_get_segment_bit(uint16 x, uint16 y) {
uint8 minorX = x & 0x1F; // 0 or 16
uint8 minorY = y & 0x1F; // 0 or 16
if (minorX == 0 && minorY == 0) {
return 3;
}
if (minorY == 16 && minorX == 16) {
return 11;
}
if (minorY == 0) {
return 15;
}
return 7;
}
money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y, uint8 rideIndex, uint8 mode, uint16 z) {
integrate variables for command position and expenditure
2016-04-24 18:53:39 +02:00
gCommandExpenditureType = RCT_EXPENDITURE_TYPE_RIDE_CONSTRUCTION;
gCommandPosition.x = x + 8;
gCommandPosition.y = y + 8;
gCommandPosition.z = z;
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
RCT2_GLOBAL(0xF4413E, money32) = 0;
if (!sub_68B044()) {
return MONEY32_UNDEFINED;
}
integrate game paused variable and refactor
2016-04-23 14:34:55 +02:00
if (!(flags & GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED) && !gCheatsBuildInPauseMode && game_is_paused()) {
integrate footpath construction variables - uint8 gFootpathProvisionalFlags - rct_xyz16 gFootpathProvisionalPosition - uint8 gFootpathConstructionMode - uint16 gFootpathSelectedId - uint8 gFootpathSelectedType - rct_xyz16 gFootpathConstructFromPosition - uint8 gFootpathConstructDirection - uint8 gFootpathConstructSlope - uint8 gFootpathConstructValidDirections Also fix some previous variable integrations that had been forgotten to change.
2016-04-15 20:16:48 +02:00
gGameCommandErrorText = STR_CONSTRUCTION_NOT_POSSIBLE_WHILE_GAME_IS_PAUSED;
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
return MONEY32_UNDEFINED;
}
if ((z & 0xF) != 0) {
// ‘Can't construct this here…’
Clean up string and sprite ID's (#3977)
2016-07-14 14:07:49 +02:00
// TODO: This string is empty
integrate footpath construction variables - uint8 gFootpathProvisionalFlags - rct_xyz16 gFootpathProvisionalPosition - uint8 gFootpathConstructionMode - uint16 gFootpathSelectedId - uint8 gFootpathSelectedType - rct_xyz16 gFootpathConstructFromPosition - uint8 gFootpathConstructDirection - uint8 gFootpathConstructSlope - uint8 gFootpathConstructValidDirections Also fix some previous variable integrations that had been forgotten to change.
2016-04-15 20:16:48 +02:00
gGameCommandErrorText = 954;
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
return MONEY32_UNDEFINED;
}
if ((flags & GAME_COMMAND_FLAG_APPLY) != 0) {
fix #3224: Maze designs clear fences and walls
2016-04-03 00:51:32 +02:00
if (!(flags & GAME_COMMAND_FLAG_GHOST) && !(flags & GAME_COMMAND_FLAG_2)) {
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
footpath_remove_litter(x, y, z);
map_remove_walls_at(floor2(x, 32), floor2(y, 32), z, z + 32);
}
}
if (!map_is_location_owned(floor2(x, 32), floor2(y, 32), z) && !gCheatsSandboxMode) {
return MONEY32_UNDEFINED;
}
rct_map_element *mapElement = map_get_surface_element_at(x / 32, y / 32);
if (mapElement == NULL) {
return MONEY32_UNDEFINED;
}
uint8 baseHeight = z >> 3;
uint8 clearanceHeight = (z + 32) >> 3;
sint8 heightDifference = baseHeight - mapElement->base_height;
if (heightDifference >= 0 && !gCheatsDisableSupportLimits) {
heightDifference = heightDifference >> 1;
Extract new struct
2016-04-03 14:53:17 +02:00
if (heightDifference > RideData5[RIDE_TYPE_MAZE].max_height) {
integrate game command error string variables - gGameCommandErrorTitle - gGameCommandErrorText
2016-04-15 18:54:46 +02:00
gGameCommandErrorText = STR_TOO_HIGH_FOR_SUPPORTS;
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
return MONEY32_UNDEFINED;
}
}
mapElement = map_get_track_element_at_of_type_from_ride(x, y, baseHeight, 0x65, rideIndex);
if (mapElement == NULL) {
if (mode != 0) {
integrate footpath construction variables - uint8 gFootpathProvisionalFlags - rct_xyz16 gFootpathProvisionalPosition - uint8 gFootpathConstructionMode - uint16 gFootpathSelectedId - uint8 gFootpathSelectedType - rct_xyz16 gFootpathConstructFromPosition - uint8 gFootpathConstructDirection - uint8 gFootpathConstructSlope - uint8 gFootpathConstructValidDirections Also fix some previous variable integrations that had been forgotten to change.
2016-04-15 20:16:48 +02:00
gGameCommandErrorText = 0;
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
return MONEY32_UNDEFINED;
}
if (!map_can_construct_at(floor2(x, 32), floor2(y, 32), baseHeight, clearanceHeight, 0x0F)) {
return MONEY32_UNDEFINED;
}
integrate ground flag variables
2016-05-17 21:51:11 +02:00
if (gMapGroundFlags & ELEMENT_IS_UNDERWATER) {
integrate footpath construction variables - uint8 gFootpathProvisionalFlags - rct_xyz16 gFootpathProvisionalPosition - uint8 gFootpathConstructionMode - uint16 gFootpathSelectedId - uint8 gFootpathSelectedType - rct_xyz16 gFootpathConstructFromPosition - uint8 gFootpathConstructDirection - uint8 gFootpathConstructSlope - uint8 gFootpathConstructValidDirections Also fix some previous variable integrations that had been forgotten to change.
2016-04-15 20:16:48 +02:00
gGameCommandErrorText = STR_RIDE_CANT_BUILD_THIS_UNDERWATER;
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
return MONEY32_UNDEFINED;
}
integrate ground flag variables
2016-05-17 21:51:11 +02:00
if (gMapGroundFlags & ELEMENT_IS_UNDERGROUND) {
integrate footpath construction variables - uint8 gFootpathProvisionalFlags - rct_xyz16 gFootpathProvisionalPosition - uint8 gFootpathConstructionMode - uint16 gFootpathSelectedId - uint8 gFootpathSelectedType - rct_xyz16 gFootpathConstructFromPosition - uint8 gFootpathConstructDirection - uint8 gFootpathConstructSlope - uint8 gFootpathConstructValidDirections Also fix some previous variable integrations that had been forgotten to change.
2016-04-15 20:16:48 +02:00
gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_ABOVE_GROUND;
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
return MONEY32_UNDEFINED;
}
rct_ride *ride = get_ride(rideIndex);
Include struct at `0x0097DD78`
2016-04-03 13:41:00 +02:00
money32 price = (((RideTrackCosts[ride->type].track_price * RCT2_GLOBAL(0x0099DBC8, money32)) >> 16));
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
RCT2_GLOBAL(0x00F4413E, money32) = price / 2 * 10;
if (!(flags & GAME_COMMAND_FLAG_APPLY)) {
add global macro: gParkFlags
2016-04-23 01:51:22 +02:00
if (gParkFlags & PARK_FLAGS_NO_MONEY) {
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
return 0;
}
return RCT2_GLOBAL(0xF4413E, money32);
}
uint16 flooredX = floor2(x, 32);
uint16 flooredY = floor2(y, 32);
mapElement = map_element_insert(x / 32, y / 32, baseHeight, 0xF);
Minor fixes
2016-02-26 20:49:01 +01:00
assert(mapElement != NULL);
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
mapElement->clearance_height = clearanceHeight;
mapElement->type = MAP_ELEMENT_TYPE_TRACK;
mapElement->properties.track.type = 0x65;
mapElement->properties.track.ride_index = rideIndex;
mapElement->properties.track.maze_entry = 0xFFFF;
if (flags & GAME_COMMAND_FLAG_GHOST) {
mapElement->flags |= MAP_ELEMENT_FLAG_GHOST;
}
map_invalidate_tile_full(flooredX, flooredY);
ride->maze_tiles++;
ride->station_heights[0] = mapElement->base_height;
ride->station_starts[0] = 0;
if (direction == 4) {
if (!(flags & GAME_COMMAND_FLAG_GHOST)) {
ride->overall_view = (flooredX >> 5) | (flooredY << 3);
}
}
}
if (!(flags & GAME_COMMAND_FLAG_APPLY)) {
add global macro: gParkFlags
2016-04-23 01:51:22 +02:00
if (gParkFlags & PARK_FLAGS_NO_MONEY) {
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
return 0;
}
return RCT2_GLOBAL(0xF4413E, money32);
}
if (mode == 0) {
// Build mode
uint8 segmentOffset = maze_element_get_segment_bit(x, y);
mapElement->properties.track.maze_entry &= ~(1 << segmentOffset);
if (direction != 4) {
segmentOffset = RCT2_GLOBAL(0x993ce9 + (direction + segmentOffset), uint8);
mapElement->properties.track.maze_entry &= ~(1 << segmentOffset);
uint8 temp_edx = RCT2_GLOBAL(0x993cfc + segmentOffset, uint8);
if (temp_edx != 0xFF) {
uint16 previousElementX = floor2(x, 32) - TileDirectionDelta[direction].x;
uint16 previousElementY = floor2(y, 32) - TileDirectionDelta[direction].y;
rct_map_element *previousMapElement = map_get_track_element_at_of_type_from_ride(previousElementX, previousElementY, baseHeight, 0x65, rideIndex);
if (previousMapElement != NULL) {
previousMapElement->properties.track.maze_entry &= ~(1 << temp_edx);
} else {
mapElement->properties.track.maze_entry |= (1 << segmentOffset);
}
}
}
} else if (mode == 1) {
// Move mode
} else {
// Fill-in mode
if (direction != 4) {
uint16 previousSegmentX = x - TileDirectionDelta[direction].x / 2;
uint16 previousSegmentY = y - TileDirectionDelta[direction].y / 2;
mapElement = map_get_track_element_at_of_type_from_ride(previousSegmentX, previousSegmentY, baseHeight, 0x65, rideIndex);
map_invalidate_tile_full(floor2(previousSegmentX, 32), floor2(previousSegmentY, 32));
if (mapElement == NULL) {
log_error("No surface found");
return MONEY32_UNDEFINED;
}
uint32 segmentBit = maze_element_get_segment_bit(previousSegmentX, previousSegmentY);
mapElement->properties.track.maze_entry |= (1 << segmentBit);
segmentBit--;
mapElement->properties.track.maze_entry |= (1 << segmentBit);
segmentBit = (segmentBit - 4) & 0x0F;
mapElement->properties.track.maze_entry |= (1 << segmentBit);
segmentBit = (segmentBit + 3) & 0x0F;
do {
mapElement->properties.track.maze_entry |= (1 << segmentBit);
uint32 direction1 = RCT2_GLOBAL(0x00993D0C + segmentBit, uint8_t);
uint16 nextElementX = floor2(previousSegmentX, 32) + TileDirectionDelta[direction1].x;
uint16 nextElementY = floor2(previousSegmentY, 32) + TileDirectionDelta[direction1].y;
rct_map_element *tmp_mapElement = map_get_track_element_at_of_type_from_ride(nextElementX, nextElementY, baseHeight, 0x65, rideIndex);
if (tmp_mapElement != NULL) {
uint8 edx11 = RCT2_GLOBAL(0x993CFC + segmentBit, uint8);
tmp_mapElement->properties.track.maze_entry |= 1 << (edx11);
}
segmentBit--;
} while ((segmentBit & 0x3) != 0x3);
}
}
map_invalidate_tile(floor2(x, 32), floor2(y, 32), mapElement->base_height * 8, mapElement->clearance_height * 8);
if ((mapElement->properties.track.maze_entry & 0x8888) == 0x8888) {
map_element_remove(mapElement);
sub_6CB945(rideIndex);
get_ride(rideIndex)->maze_tiles--;
}
add global macro: gParkFlags
2016-04-23 01:51:22 +02:00
if (gParkFlags & PARK_FLAGS_NO_MONEY) {
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
return 0;
}
return RCT2_GLOBAL(0xF4413E, money32);
}
add callfunc wrappers for the last three remaining game commands and remove original call table
2015-10-10 21:26:17 +02:00
/**
*
* rct2: 0x006CD8CE
*/
void game_command_set_maze_track(int *eax, int *ebx, int *ecx, int *edx, int *esi, int *edi, int *ebp)
{
Decompile game_command_set_maze_track
2016-01-21 02:43:33 +01:00
uint16 x = (*eax & 0xFFFF); // AX
uint8 flags = (*ebx & 0xFF); // BL
uint8 direction = ((*ebx & 0xFF00) >> 8); // BH
uint16 y = (*ecx & 0xFFFF); // CX
uint8 rideIndex = (*edx & 0xFF); // DL
uint8 mode = ((*edx & 0xFF00) >> 8); // DH
uint16 z = (*edi & 0xFFFF); // DI
*ebx = set_maze_track(x, flags, direction, y, rideIndex, mode, z);
add callfunc wrappers for the last three remaining game commands and remove original call table
2015-10-10 21:26:17 +02:00
}
fix setting brakes speed on current track and implement game command
2015-06-28 12:44:34 +02:00
/**
*
* rct2: 0x006C5AE9
*/
void game_command_set_brakes_speed(int *eax, int *ebx, int *ecx, int *edx, int *esi, int *edi, int *ebp)
{
rct_map_element *mapElement;
int x, y, z, trackType, brakesSpeed;
x = (*eax & 0xFFFF);
y = (*ecx & 0xFFFF);
z = (*edi & 0xFFFF);
trackType = (*edx & 0xFF);
brakesSpeed = ((*ebx >> 8) & 0xFF);
integrate variables for command position and expenditure
2016-04-24 18:53:39 +02:00
gCommandExpenditureType = RCT_EXPENDITURE_TYPE_RIDE_CONSTRUCTION;
gCommandPosition.x = x + 16;
gCommandPosition.y = y + 16;
gCommandPosition.z = z;
fix setting brakes speed on current track and implement game command
2015-06-28 12:44:34 +02:00
if (*ebx & GAME_COMMAND_FLAG_APPLY) {
*ebx = 0;
return;
}
mapElement = map_get_first_element_at(x >> 5, y >> 5);
Game commands hardening
2016-01-03 00:49:08 +01:00
if (mapElement == NULL)
{
log_warning("Invalid game command for setting brakes speed. x = %d, y = %d", x, y);
*ebx = MONEY32_UNDEFINED;
return;
}
fix setting brakes speed on current track and implement game command
2015-06-28 12:44:34 +02:00
do {
if (mapElement->base_height * 8 != z)
continue;
if (map_element_get_type(mapElement) != MAP_ELEMENT_TYPE_TRACK)
continue;
if (mapElement->properties.track.type != trackType)
continue;
mapElement->properties.track.sequence =
(mapElement->properties.track.sequence & 0x0F) |
((brakesSpeed >> 1) << 4);
break;
} while (!map_element_is_last_for_tile(mapElement++));
*ebx = 0;
implement ride_check_track_contains_inversions, ride_check_track_contains_banked, refactor track circuit iteration and fix window event bug with hook
2015-07-11 23:51:11 +02:00
}
void track_circuit_iterator_begin(track_circuit_iterator *it, rct_xy_element first)
{
it->last = first;
it->first = NULL;
it->firstIteration = true;
it->looped = false;
}
implement sub_6D31A6
2015-09-13 03:59:55 +02:00
bool track_circuit_iterator_previous(track_circuit_iterator *it)
{
track_begin_end trackBeginEnd;
if (it->first == NULL) {
if (!track_block_get_previous(it->last.x, it->last.y, it->last.element, &trackBeginEnd))
return false;
it->current.x = trackBeginEnd.begin_x;
it->current.y = trackBeginEnd.begin_y;
it->current.element = trackBeginEnd.begin_element;
it->currentZ = trackBeginEnd.begin_z;
it->currentDirection = trackBeginEnd.begin_direction;
it->first = it->current.element;
return true;
} else {
if (!it->firstIteration && it->first == it->current.element) {
it->looped = true;
return false;
}
it->firstIteration = false;
it->last = it->current;
if (track_block_get_previous(it->last.x, it->last.y, it->last.element, &trackBeginEnd)) {
Fixed #2082. Sub_6D31A6 now working. Small mistake in track previous meant the x/y coordinates didn't match the map element. There were also a few other issues that presented themselves once that was fixed.
2015-11-03 21:03:21 +01:00
it->current.x = trackBeginEnd.end_x;
it->current.y = trackBeginEnd.end_y;
implement sub_6D31A6
2015-09-13 03:59:55 +02:00
it->current.element = trackBeginEnd.begin_element;
it->currentZ = trackBeginEnd.begin_z;
it->currentDirection = trackBeginEnd.begin_direction;
return true;
} else {
return false;
}
}
}
implement ride_check_track_contains_inversions, ride_check_track_contains_banked, refactor track circuit iteration and fix window event bug with hook
2015-07-11 23:51:11 +02:00
bool track_circuit_iterator_next(track_circuit_iterator *it)
{
if (it->first == NULL) {
if (!track_block_get_next(&it->last, &it->current, &it->currentZ, &it->currentDirection))
return false;
it->first = it->current.element;
return true;
} else {
if (!it->firstIteration && it->first == it->current.element) {
it->looped = true;
return false;
}
it->firstIteration = false;
it->last = it->current;
return track_block_get_next(&it->last, &it->current, &it->currentZ, &it->currentDirection);
}
}
implement ride_check_start_and_end_is_station and fix #1575
2015-07-12 15:26:14 +02:00
void track_get_back(rct_xy_element *input, rct_xy_element *output)
{
rct_xy_element lastTrack;
track_begin_end currentTrack;
bool result;
lastTrack = *input;
do {
result = track_block_get_previous(lastTrack.x, lastTrack.y, lastTrack.element, &currentTrack);
if (result) {
lastTrack.x = currentTrack.begin_x;
lastTrack.y = currentTrack.begin_y;
lastTrack.element = currentTrack.begin_element;
}
} while (result);
*output = lastTrack;
}
void track_get_front(rct_xy_element *input, rct_xy_element *output)
{
rct_xy_element lastTrack, currentTrack;
int z, direction;
bool result;
lastTrack = *input;
do {
result = track_block_get_next(&lastTrack, &currentTrack, &z, &direction);
if (result) {
lastTrack = currentTrack;
}
} while (result);
*output = lastTrack;
}
add vehicle struct, enum labels and helper functions from implement-ride-create-vehicles branch.
2015-10-25 17:00:21 +01:00
bool track_element_is_lift_hill(rct_map_element *trackElement)
{
return trackElement->type & 0x80;
}
Refactor. Labelled the known flags and used functions for setting and clearing them.
2015-11-04 20:28:45 +01:00
implement more sub_6DAB4C
2015-11-01 15:58:46 +01:00
/**
* Checks if a track element is recognised as the beginning of a block.
* A beginning of a block can be the end of a station, the end of a lift hill,
* or a block brake.
*/
bool track_element_is_block_start(rct_map_element *trackElement)
{
switch (trackElement->properties.track.type) {
case TRACK_ELEM_END_STATION:
case TRACK_ELEM_CABLE_LIFT_HILL:
case 216:
return true;
case TRACK_ELEM_25_DEG_UP_TO_FLAT:
case TRACK_ELEM_60_DEG_UP_TO_FLAT:
case TRACK_ELEM_DIAG_25_DEG_UP_TO_FLAT:
case TRACK_ELEM_DIAG_60_DEG_UP_TO_FLAT:
if (track_element_is_lift_hill(trackElement)) {
return true;
}
break;
}
return false;
}
Refactor. Labelled the known flags and used functions for setting and clearing them.
2015-11-04 20:28:45 +01:00
bool track_element_is_cable_lift(rct_map_element *trackElement) {
return trackElement->properties.track.colour & TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
}
void track_element_set_cable_lift(rct_map_element *trackElement) {
trackElement->properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
}
void track_element_clear_cable_lift(rct_map_element *trackElement) {
trackElement->properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
}
implement more sub_6DAB4C
2015-11-22 13:14:53 +01:00
int track_get_actual_bank(rct_map_element *mapElement, int bank)
{
Refactor rides to be only accessible with getters This changes how rides are accessed from macros to getter functions.
2016-01-22 15:38:52 +01:00
rct_ride *ride = get_ride(mapElement->properties.track.ride_index);
implement more sub_6DAB4C
2015-11-22 13:14:53 +01:00
int trackColour = mapElement->properties.track.colour;
return track_get_actual_bank_2(ride->type, trackColour, bank);
}
int track_get_actual_bank_2(int rideType, int trackColour, int bank)
{
if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_3) {
if (trackColour & 4) {
if (bank == TRACK_BANK_NONE) {
bank = TRACK_BANK_UPSIDE_DOWN;
} else if (bank == TRACK_BANK_UPSIDE_DOWN) {
bank = TRACK_BANK_NONE;
}
}
}
return bank;
}
implement more sub_6DAB4C
2015-11-22 15:55:46 +01:00
implement more sub_6DAB4C
2015-12-13 17:10:30 +01:00
int track_get_actual_bank_3(rct_vehicle *vehicle, rct_map_element *mapElement)
{
Fix more vehicle bugs. Changed sub_6DD078 to change the collide vehicle
2015-12-18 21:33:45 +01:00
uint8 colourThingToXor = (vehicle->update_flags >> 9) & 0xFF;
implement more sub_6DAB4C
2015-12-13 17:10:30 +01:00
int trackType = mapElement->properties.track.type;
Refactor rides to be only accessible with getters This changes how rides are accessed from macros to getter functions.
2016-01-22 15:38:52 +01:00
int rideType = get_ride(mapElement->properties.track.ride_index)->type;
implement more sub_6DAB4C
2015-12-13 17:10:30 +01:00
int trackColour = mapElement->properties.track.colour ^ colourThingToXor;
int bankStart = gTrackDefinitions[trackType].bank_start;
return track_get_actual_bank_2(rideType, trackColour, bankStart);
}
implement more sub_6DAB4C
2015-11-22 15:55:46 +01:00
bool track_element_is_station(rct_map_element *trackElement)
{
switch (trackElement->properties.track.type) {
case TRACK_ELEM_END_STATION:
case TRACK_ELEM_BEGIN_STATION:
case TRACK_ELEM_MIDDLE_STATION:
return true;
default:
return false;
}
}
implement more sub_6DAB4C
2015-11-22 18:50:33 +01:00
bool track_element_is_covered(int trackElementType)
{
switch (trackElementType) {
case TRACK_ELEM_FLAT_COVERED:
case TRACK_ELEM_25_DEG_UP_COVERED:
case TRACK_ELEM_60_DEG_UP_COVERED:
case TRACK_ELEM_FLAT_TO_25_DEG_UP_COVERED:
case TRACK_ELEM_25_DEG_UP_TO_60_DEG_UP_COVERED:
case TRACK_ELEM_60_DEG_UP_TO_25_DEG_UP_COVERED:
case TRACK_ELEM_25_DEG_UP_TO_FLAT_COVERED:
case TRACK_ELEM_25_DEG_DOWN_COVERED:
case TRACK_ELEM_60_DEG_DOWN_COVERED:
case TRACK_ELEM_FLAT_TO_25_DEG_DOWN_COVERED:
case TRACK_ELEM_25_DEG_DOWN_TO_60_DEG_DOWN_COVERED:
case TRACK_ELEM_60_DEG_DOWN_TO_25_DEG_DOWN_COVERED:
case TRACK_ELEM_25_DEG_DOWN_TO_FLAT_COVERED:
case TRACK_ELEM_LEFT_QUARTER_TURN_5_TILES_COVERED:
case TRACK_ELEM_RIGHT_QUARTER_TURN_5_TILES_COVERED:
case TRACK_ELEM_S_BEND_LEFT_COVERED:
case TRACK_ELEM_S_BEND_RIGHT_COVERED:
case TRACK_ELEM_LEFT_QUARTER_TURN_3_TILES_COVERED:
case TRACK_ELEM_RIGHT_QUARTER_TURN_3_TILES_COVERED:
return true;
default:
return false;
}
}