mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2025-12-10 09:32:29 +01:00
Code Issues Releases Wiki Activity

Remove dead code

Browse Source
This commit is contained in:
duncanspumpkin
2019-06-30 10:15:39 +01:00
parent 02d552e048
commit 16022a8b57
1 changed files with 0 additions and 368 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -89,18 +89,12 @@ static bool _trackDesignPlaceStateSceneryUnavailable = false;
static bool _trackDesignPlaceStateHasScenery = false;
static bool _trackDesignPlaceStatePlaceScenery = true;
static rct_track_td6* track_design_open_from_buffer(uint8_t* src, size_t srcLength);
static map_backup* track_design_preview_backup_map();
static void track_design_preview_restore_map(map_backup* backup);
static void track_design_preview_clear_map();
static void td6_reset_trailing_elements(rct_track_td6* td6);
static void td6_set_element_helper_pointers(rct_track_td6* td6, bool clearScenery);
std::unique_ptr<TrackDesign> track_design_open(const utf8* path)
{
auto trackImporter = TrackImporter::Create(path);
@@ -117,370 +111,8 @@ std::unique_ptr<TrackDesign> track_design_open(const utf8* path)
}
log_verbose("track_design_open(\"%s\")", path);
return nullptr;
//try
//{
// auto buffer = File::ReadAllBytes(path);
// if (!sawyercoding_validate_track_checksum(buffer.data(), buffer.size()))
// {
// log_error("Track checksum failed. %s", path);
// return nullptr;
// }
// // Decode the track data
// uint8_t* decoded = (uint8_t*)malloc(0x10000);
// size_t decodedLength = sawyercoding_decode_td6(buffer.data(), decoded, buffer.size());
// decoded = (uint8_t*)realloc(decoded, decodedLength);
// if (decoded == nullptr)
// {
// log_error("failed to realloc");
// }
// else
// {
// rct_track_td6* td6 = track_design_open_from_buffer(decoded, decodedLength);
// free(decoded);
// if (td6 != nullptr)
// {
// td6->name = String::Duplicate(GetNameFromTrackPath(path).c_str());
// return td6;
// }
// }
//}
//catch (const std::exception& e)
//{
// log_error("Unable to load track design: %s", e.what());
//}
//return nullptr;
}
//static rct_track_td6* track_design_open_from_td4(uint8_t* src, size_t srcLength)
//{
// rct_track_td4* td4 = (rct_track_td4*)calloc(1, sizeof(rct_track_td4));
// if (td4 == nullptr)
// {
// log_error("Unable to allocate memory for TD4 data.");
// SafeFree(td4);
// return nullptr;
// }
//
// uint8_t version = (src[7] >> 2) & 3;
// if (version == 0)
// {
// std::memcpy(td4, src, 0x38);
// td4->elementsSize = srcLength - 0x38;
// td4->elements = malloc(td4->elementsSize);
// if (td4->elements == nullptr)
// {
// log_error("Unable to allocate memory for TD4 element data.");
// SafeFree(td4);
// return nullptr;
// }
// std::memcpy(td4->elements, src + 0x38, td4->elementsSize);
// }
// else if (version == 1)
// {
// std::memcpy(td4, src, 0xC4);
// td4->elementsSize = srcLength - 0xC4;
// td4->elements = malloc(td4->elementsSize);
// if (td4->elements == nullptr)
// {
// log_error("Unable to allocate memory for TD4 element data.");
// SafeFree(td4);
// return nullptr;
// }
// std::memcpy(td4->elements, src + 0xC4, td4->elementsSize);
// }
// else
// {
// log_error("Unsupported track design.");
// SafeFree(td4);
// return nullptr;
// }
//
// rct_track_td6* td6 = (rct_track_td6*)calloc(1, sizeof(rct_track_td6));
// if (td6 == nullptr)
// {
// log_error("Unable to allocate memory for TD6 data.");
// SafeFree(td4);
// return nullptr;
// }
//
// td6->type = RCT1::GetRideType(td4->type);
//
// // All TD4s that use powered launch use the type that doesn't pass the station.
// td6->ride_mode = td4->mode;
// if (td4->mode == RCT1_RIDE_MODE_POWERED_LAUNCH)
// {
// td6->ride_mode = RIDE_MODE_POWERED_LAUNCH;
// }
//
// // Convert RCT1 vehicle type to RCT2 vehicle type. Intialise with an string consisting of 8 spaces.
// rct_object_entry vehicleObject = { 0x80, " " };
// if (td4->type == RIDE_TYPE_MAZE)
// {
// const char* name = RCT1::GetRideTypeObject(td4->type);
// assert(name != nullptr);
// std::memcpy(vehicleObject.name, name, std::min(String::SizeOf(name), (size_t)8));
// }
// else
// {
// const char* name = RCT1::GetVehicleObject(td4->vehicle_type);
// assert(name != nullptr);
// std::memcpy(vehicleObject.name, name, std::min(String::SizeOf(name), (size_t)8));
// }
// std::memcpy(&td6->vehicle_object, &vehicleObject, sizeof(rct_object_entry));
// td6->vehicle_type = td4->vehicle_type;
//
// td6->flags = td4->flags;
// td6->version_and_colour_scheme = td4->version_and_colour_scheme;
//
// // Vehicle colours
// for (int32_t i = 0; i < RCT1_MAX_TRAINS_PER_RIDE; i++)
// {
// // RCT1 had no third colour
// RCT1::RCT1VehicleColourSchemeCopyDescriptor colourSchemeCopyDescriptor = RCT1::GetColourSchemeCopyDescriptor(
// td4->vehicle_type);
// if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_1)
// {
// td6->vehicle_colours[i].body_colour = RCT1::GetColour(td4->vehicle_colours[i].body_colour);
// }
// else if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_2)
// {
// td6->vehicle_colours[i].body_colour = RCT1::GetColour(td4->vehicle_colours[i].trim_colour);
// }
// else
// {
// td6->vehicle_colours[i].body_colour = colourSchemeCopyDescriptor.colour1;
// }
//
// if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_1)
// {
// td6->vehicle_colours[i].trim_colour = RCT1::GetColour(td4->vehicle_colours[i].body_colour);
// }
// else if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_2)
// {
// td6->vehicle_colours[i].trim_colour = RCT1::GetColour(td4->vehicle_colours[i].trim_colour);
// }
// else
// {
// td6->vehicle_colours[i].trim_colour = colourSchemeCopyDescriptor.colour2;
// }
//
// if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_1)
// {
// td6->vehicle_additional_colour[i] = RCT1::GetColour(td4->vehicle_colours[i].body_colour);
// }
// else if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_2)
// {
// td6->vehicle_additional_colour[i] = RCT1::GetColour(td4->vehicle_colours[i].trim_colour);
// }
// else
// {
// td6->vehicle_additional_colour[i] = colourSchemeCopyDescriptor.colour3;
// }
// }
// // Set remaining vehicles to same colour as first vehicle
// for (int32_t i = RCT1_MAX_TRAINS_PER_RIDE; i < MAX_VEHICLES_PER_RIDE; i++)
// {
// td6->vehicle_colours[i] = td6->vehicle_colours[0];
// td6->vehicle_additional_colour[i] = td6->vehicle_additional_colour[0];
// }
//
// // Track colours
// if (version == 0)
// {
// for (int32_t i = 0; i < NUM_COLOUR_SCHEMES; i++)
// {
// td6->track_spine_colour[i] = RCT1::GetColour(td4->track_spine_colour_v0);
// td6->track_rail_colour[i] = RCT1::GetColour(td4->track_rail_colour_v0);
// td6->track_support_colour[i] = RCT1::GetColour(td4->track_support_colour_v0);
//
// // Mazes were only hedges
// switch (td4->type)
// {
// case RCT1_RIDE_TYPE_HEDGE_MAZE:
// td6->track_support_colour[i] = MAZE_WALL_TYPE_HEDGE;
// break;
// case RCT1_RIDE_TYPE_RIVER_RAPIDS:
// td6->track_spine_colour[i] = COLOUR_WHITE;
// td6->track_rail_colour[i] = COLOUR_WHITE;
// break;
// }
// }
// }
// else
// {
// for (int32_t i = 0; i < RCT12_NUM_COLOUR_SCHEMES; i++)
// {
// td6->track_spine_colour[i] = RCT1::GetColour(td4->track_spine_colour[i]);
// td6->track_rail_colour[i] = RCT1::GetColour(td4->track_rail_colour[i]);
// td6->track_support_colour[i] = RCT1::GetColour(td4->track_support_colour[i]);
// }
// }
//
// td6->depart_flags = td4->depart_flags;
// td6->number_of_trains = td4->number_of_trains;
// td6->number_of_cars_per_train = td4->number_of_cars_per_train;
// td6->min_waiting_time = td4->min_waiting_time;
// td6->max_waiting_time = td4->max_waiting_time;
// td6->operation_setting = std::min(td4->operation_setting, RideProperties[td6->type].max_value);
// td6->max_speed = td4->max_speed;
// td6->average_speed = td4->average_speed;
// td6->ride_length = td4->ride_length;
// td6->max_positive_vertical_g = td4->max_positive_vertical_g;
// td6->max_negative_vertical_g = td4->max_negative_vertical_g;
// td6->max_lateral_g = td4->max_lateral_g;
// td6->inversions = td4->num_inversions;
// td6->drops = td4->num_drops;
// td6->highest_drop_height = td4->highest_drop_height / 2;
// td6->excitement = td4->excitement;
// td6->intensity = td4->intensity;
// td6->nausea = td4->nausea;
// td6->upkeep_cost = td4->upkeep_cost;
// if (version == 1)
// {
// td6->flags2 = td4->flags2;
// }
//
// td6->space_required_x = 255;
// td6->space_required_y = 255;
// td6->lift_hill_speed_num_circuits = 5;
//
// // Move elements across
// td6->elements = td4->elements;
// td6->elementsSize = td4->elementsSize;
//
// td6_reset_trailing_elements(td6);
// td6_set_element_helper_pointers(td6, true);
//
// SafeFree(td4);
// return td6;
//}
//
//static rct_track_td6* track_design_open_from_buffer(uint8_t* src, size_t srcLength)
//{
// uint8_t version = (src[7] >> 2) & 3;
// if (version == 0 || version == 1)
// {
// return track_design_open_from_td4(src, srcLength);
// }
// else if (version != 2)
// {
// log_error("Unsupported track design.");
// return nullptr;
// }
//
// rct_track_td6* td6 = (rct_track_td6*)calloc(1, sizeof(rct_track_td6));
// if (td6 == nullptr)
// {
// log_error("Unable to allocate memory for TD6 data.");
// return nullptr;
// }
// std::memcpy(td6, src, 0xA3);
// td6->elementsSize = srcLength - 0xA3;
// td6->elements = malloc(td6->elementsSize);
// if (td6->elements == nullptr)
// {
// free(td6);
// log_error("Unable to allocate memory for TD6 element data.");
// return nullptr;
// }
// std::memcpy(td6->elements, src + 0xA3, td6->elementsSize);
//
// // Cap operation setting
// td6->operation_setting = std::min(td6->operation_setting, RideProperties[td6->type].max_value);
//
// td6_set_element_helper_pointers(td6, false);
// return td6;
//}
//
//static void td6_reset_trailing_elements(rct_track_td6* td6)
//{
// void* lastElement;
// if (td6->type == RIDE_TYPE_MAZE)
// {
// rct_td6_maze_element* mazeElement = (rct_td6_maze_element*)td6->elements;
// while (mazeElement->all != 0)
// {
// mazeElement++;
// }
// lastElement = (void*)((uintptr_t)mazeElement + 1);
//
// size_t trailingSize = td6->elementsSize - (size_t)((uintptr_t)lastElement - (uintptr_t)td6->elements);
// std::memset(lastElement, 0, trailingSize);
// }
// else
// {
// rct_td6_track_element* trackElement = (rct_td6_track_element*)td6->elements;
// while (trackElement->type != 0xFF)
// {
// trackElement++;
// }
// lastElement = (void*)((uintptr_t)trackElement + 1);
//
// size_t trailingSize = td6->elementsSize - (size_t)((uintptr_t)lastElement - (uintptr_t)td6->elements);
// std::memset(lastElement, 0xFF, trailingSize);
// }
//}
//
///**
// *
// * @param clearScenery Set when importing TD4 designs, to avoid corrupted data being interpreted as scenery.
// */
//static void td6_set_element_helper_pointers(rct_track_td6* td6, bool clearScenery)
//{
// uintptr_t sceneryElementsStart;
//
// if (td6->type == RIDE_TYPE_MAZE)
// {
// td6->track_elements = nullptr;
// td6->maze_elements = (rct_td6_maze_element*)td6->elements;
//
// rct_td6_maze_element* maze = td6->maze_elements;
// for (; maze->all != 0; maze++)
// {
// }
// sceneryElementsStart = (uintptr_t)(++maze);
// }
// else
// {
// td6->maze_elements = nullptr;
// td6->track_elements = (rct_td6_track_element*)td6->elements;
//
// rct_td6_track_element* track = td6->track_elements;
// for (; track->type != 0xFF; track++)
// {
// }
// uintptr_t entranceElementsStart = (uintptr_t)track + 1;
//
// rct_td6_entrance_element* entranceElement = (rct_td6_entrance_element*)entranceElementsStart;
// td6->entrance_elements = entranceElement;
// for (; entranceElement->z != -1; entranceElement++)
// {
// }
// sceneryElementsStart = (uintptr_t)entranceElement + 1;
// }
//
// if (clearScenery)
// {
// td6->scenery_elements = nullptr;
// }
// else
// {
// rct_td6_scenery_element* sceneryElement = (rct_td6_scenery_element*)sceneryElementsStart;
// td6->scenery_elements = sceneryElement;
// }
//}
//
//void track_design_dispose(rct_track_td6* td6)
//{
// if (td6 != nullptr)
// {
// free(td6->elements);
// free(td6->name);
// free(td6);
// }
//}
/**
*