2016-05-07 14:58:36 +02:00
|
|
|
#pragma region Copyright (c) 2014-2016 OpenRCT2 Developers
|
|
|
|
/*****************************************************************************
|
|
|
|
* OpenRCT2, an open source clone of Roller Coaster Tycoon 2.
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* A full copy of the GNU General Public License can be found in licence.txt
|
|
|
|
*****************************************************************************/
|
|
|
|
#pragma endregion
|
|
|
|
|
2017-01-31 19:37:55 +01:00
|
|
|
#include "../core/Console.hpp"
|
2016-05-07 14:58:36 +02:00
|
|
|
#include "../core/Exception.hpp"
|
2017-01-31 00:56:10 +01:00
|
|
|
#include "../core/FileStream.hpp"
|
2016-05-07 14:58:36 +02:00
|
|
|
#include "../core/IStream.hpp"
|
2017-01-31 00:56:10 +01:00
|
|
|
#include "../core/Path.hpp"
|
|
|
|
#include "../core/String.hpp"
|
2017-01-14 19:47:18 +01:00
|
|
|
#include "../management/award.h"
|
2016-06-03 23:03:22 +02:00
|
|
|
#include "../network/network.h"
|
2017-02-04 01:34:14 +01:00
|
|
|
#include "../object/ObjectRepository.h"
|
2017-01-31 00:56:10 +01:00
|
|
|
#include "../ParkImporter.h"
|
|
|
|
#include "../rct12/SawyerEncoding.h"
|
2017-02-05 03:33:15 +01:00
|
|
|
#include "../rct12/SawyerChunkReader.h"
|
2016-05-07 14:58:36 +02:00
|
|
|
|
|
|
|
extern "C"
|
|
|
|
{
|
2017-02-18 16:45:10 +01:00
|
|
|
#include "../config/Config.h"
|
2016-05-07 18:37:50 +02:00
|
|
|
#include "../game.h"
|
2016-05-09 00:16:25 +02:00
|
|
|
#include "../interface/viewport.h"
|
2016-05-07 17:20:10 +02:00
|
|
|
#include "../localisation/date.h"
|
|
|
|
#include "../localisation/localisation.h"
|
|
|
|
#include "../management/finance.h"
|
|
|
|
#include "../management/marketing.h"
|
|
|
|
#include "../management/news_item.h"
|
|
|
|
#include "../management/research.h"
|
2016-12-11 01:12:29 +01:00
|
|
|
#include "../OpenRCT2.h"
|
2016-05-07 17:20:10 +02:00
|
|
|
#include "../peep/staff.h"
|
2016-11-30 12:07:10 +01:00
|
|
|
#include "../rct2.h"
|
2016-05-07 17:20:10 +02:00
|
|
|
#include "../ride/ride.h"
|
|
|
|
#include "../ride/ride_ratings.h"
|
2016-12-14 13:13:52 +01:00
|
|
|
#include "../scenario/scenario.h"
|
2016-05-07 14:58:36 +02:00
|
|
|
#include "../util/sawyercoding.h"
|
2017-03-11 12:24:18 +01:00
|
|
|
#include "../world/Climate.h"
|
2016-05-07 17:20:10 +02:00
|
|
|
#include "../world/map_animation.h"
|
|
|
|
#include "../world/park.h"
|
2016-05-07 14:58:36 +02:00
|
|
|
}
|
|
|
|
|
2016-05-07 23:47:29 +02:00
|
|
|
class ObjectLoadException : public Exception
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
ObjectLoadException() : Exception("Unable to load objects.") { }
|
2016-11-30 23:32:47 +01:00
|
|
|
explicit ObjectLoadException(const char * message) : Exception(message) { }
|
2016-05-07 23:47:29 +02:00
|
|
|
};
|
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
/**
|
|
|
|
* Class to import RollerCoaster Tycoon 2 scenarios (*.SC6) and saved games (*.SV6).
|
|
|
|
*/
|
|
|
|
class S6Importer final : public IParkImporter
|
2016-05-07 14:58:36 +02:00
|
|
|
{
|
2017-01-31 00:56:10 +01:00
|
|
|
private:
|
|
|
|
const utf8 * _s6Path = nullptr;
|
2017-01-31 21:27:53 +01:00
|
|
|
rct_s6_data _s6;
|
2017-01-31 00:56:10 +01:00
|
|
|
uint8 _gameVersion = 0;
|
2016-05-07 14:58:36 +02:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
public:
|
2017-01-31 21:27:53 +01:00
|
|
|
S6Importer()
|
|
|
|
{
|
|
|
|
Memory::Set(&_s6, 0, sizeof(_s6));
|
|
|
|
}
|
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
void Load(const utf8 * path) override
|
2016-05-08 02:22:32 +02:00
|
|
|
{
|
2017-01-31 00:56:10 +01:00
|
|
|
const utf8 * extension = Path::GetExtension(path);
|
|
|
|
if (String::Equals(extension, ".sc6", true))
|
|
|
|
{
|
|
|
|
LoadScenario(path);
|
|
|
|
}
|
|
|
|
else if (String::Equals(extension, ".sv6", true))
|
|
|
|
{
|
|
|
|
LoadSavedGame(path);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
throw Exception("Invalid RCT2 park extension.");
|
|
|
|
}
|
2016-05-07 14:58:36 +02:00
|
|
|
}
|
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
void LoadSavedGame(const utf8 * path) override
|
2016-05-07 23:47:29 +02:00
|
|
|
{
|
2017-01-31 00:56:10 +01:00
|
|
|
auto fs = FileStream(path, FILE_MODE_OPEN);
|
|
|
|
LoadFromStream(&fs, false);
|
|
|
|
_s6Path = path;
|
2016-05-07 23:47:29 +02:00
|
|
|
}
|
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
void LoadScenario(const utf8 * path) override
|
2016-05-08 02:22:32 +02:00
|
|
|
{
|
2017-01-31 00:56:10 +01:00
|
|
|
auto fs = FileStream(path, FILE_MODE_OPEN);
|
|
|
|
LoadFromStream(&fs, true);
|
|
|
|
_s6Path = path;
|
2016-05-07 14:58:36 +02:00
|
|
|
}
|
|
|
|
|
2017-01-31 21:27:53 +01:00
|
|
|
void LoadFromStream(IStream * stream, bool isScenario) override
|
2016-05-07 23:47:29 +02:00
|
|
|
{
|
2017-02-04 12:05:25 +01:00
|
|
|
if (isScenario && !gConfigGeneral.allow_loading_with_incorrect_checksum && !SawyerEncoding::ValidateChecksum(stream))
|
2017-01-31 21:19:26 +01:00
|
|
|
{
|
|
|
|
throw IOException("Invalid checksum.");
|
|
|
|
}
|
|
|
|
|
2017-02-05 03:33:15 +01:00
|
|
|
auto chunkReader = SawyerChunkReader(stream);
|
|
|
|
chunkReader.ReadChunk(&_s6.header, sizeof(_s6.header));
|
2016-05-07 23:47:29 +02:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
log_verbose("saved game classic_flag = 0x%02x\n", _s6.header.classic_flag);
|
|
|
|
if (isScenario)
|
|
|
|
{
|
|
|
|
if (_s6.header.type != S6_TYPE_SCENARIO)
|
|
|
|
{
|
|
|
|
throw Exception("Park is not a scenario.");
|
|
|
|
}
|
2017-02-05 03:33:15 +01:00
|
|
|
chunkReader.ReadChunk(&_s6.info, sizeof(_s6.info));
|
2017-01-31 00:56:10 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (_s6.header.type != S6_TYPE_SAVEDGAME)
|
|
|
|
{
|
|
|
|
throw Exception("Park is not a saved game.");
|
|
|
|
}
|
|
|
|
}
|
2016-05-07 14:58:36 +02:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
// Read packed objects
|
|
|
|
// TODO try to contain this more and not store objects until later
|
2017-02-04 01:34:14 +01:00
|
|
|
IObjectRepository * objectRepo = GetObjectRepository();
|
2017-01-31 00:56:10 +01:00
|
|
|
for (uint16 i = 0; i < _s6.header.num_packed_objects; i++)
|
|
|
|
{
|
2017-02-05 16:45:23 +01:00
|
|
|
objectRepo->ExportPackedObject(stream);
|
2017-01-31 00:56:10 +01:00
|
|
|
}
|
2016-05-07 14:58:36 +02:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
if (isScenario)
|
|
|
|
{
|
2017-02-05 03:33:15 +01:00
|
|
|
chunkReader.ReadChunk(&_s6.objects, sizeof(_s6.objects));
|
|
|
|
chunkReader.ReadChunk(&_s6.elapsed_months, 16);
|
|
|
|
chunkReader.ReadChunk(&_s6.map_elements, sizeof(_s6.map_elements));
|
|
|
|
chunkReader.ReadChunk(&_s6.next_free_map_element_pointer_index, 2560076);
|
|
|
|
chunkReader.ReadChunk(&_s6.guests_in_park, 4);
|
|
|
|
chunkReader.ReadChunk(&_s6.last_guests_in_park, 8);
|
|
|
|
chunkReader.ReadChunk(&_s6.park_rating, 2);
|
|
|
|
chunkReader.ReadChunk(&_s6.active_research_types, 1082);
|
|
|
|
chunkReader.ReadChunk(&_s6.current_expenditure, 16);
|
|
|
|
chunkReader.ReadChunk(&_s6.park_value, 4);
|
|
|
|
chunkReader.ReadChunk(&_s6.completed_company_value, 483816);
|
2017-01-31 00:56:10 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-02-05 03:33:15 +01:00
|
|
|
chunkReader.ReadChunk(&_s6.objects, sizeof(_s6.objects));
|
|
|
|
chunkReader.ReadChunk(&_s6.elapsed_months, 16);
|
|
|
|
chunkReader.ReadChunk(&_s6.map_elements, sizeof(_s6.map_elements));
|
|
|
|
chunkReader.ReadChunk(&_s6.next_free_map_element_pointer_index, 3048816);
|
2017-01-31 00:56:10 +01:00
|
|
|
}
|
2016-05-07 14:58:36 +02:00
|
|
|
}
|
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
bool GetDetails(scenario_index_entry * dst) override
|
2016-05-07 23:47:29 +02:00
|
|
|
{
|
2017-01-31 00:56:10 +01:00
|
|
|
Memory::Set(dst, 0, sizeof(scenario_index_entry));
|
|
|
|
return false;
|
2016-05-07 23:47:29 +02:00
|
|
|
}
|
2016-05-07 14:58:36 +02:00
|
|
|
|
2017-01-31 21:27:53 +01:00
|
|
|
void Import() override
|
2016-07-03 22:05:18 +02:00
|
|
|
{
|
2017-01-31 00:56:10 +01:00
|
|
|
Initialise();
|
2016-05-07 14:58:36 +02:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
// _s6.header
|
|
|
|
gS6Info = _s6.info;
|
2016-05-07 14:58:36 +02:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
gDateMonthsElapsed = _s6.elapsed_months;
|
|
|
|
gDateMonthTicks = _s6.current_day;
|
|
|
|
gScenarioTicks = _s6.scenario_ticks;
|
|
|
|
gScenarioSrand0 = _s6.scenario_srand_0;
|
|
|
|
gScenarioSrand1 = _s6.scenario_srand_1;
|
2017-01-23 14:00:46 +01:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
memcpy(gMapElements, _s6.map_elements, sizeof(_s6.map_elements));
|
2016-05-07 18:37:50 +02:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
gNextFreeMapElementPointerIndex = _s6.next_free_map_element_pointer_index;
|
|
|
|
for (sint32 i = 0; i < MAX_SPRITES; i++)
|
|
|
|
{
|
|
|
|
memcpy(get_sprite(i), &_s6.sprites[i], sizeof(rct_sprite));
|
|
|
|
}
|
2016-05-07 14:58:36 +02:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
for (sint32 i = 0; i < NUM_SPRITE_LISTS; i++)
|
|
|
|
{
|
|
|
|
gSpriteListHead[i] = _s6.sprite_lists_head[i];
|
|
|
|
gSpriteListCount[i] = _s6.sprite_lists_count[i];
|
|
|
|
}
|
|
|
|
gParkName = _s6.park_name;
|
|
|
|
// pad_013573D6
|
|
|
|
gParkNameArgs = _s6.park_name_args;
|
|
|
|
gInitialCash = _s6.initial_cash;
|
|
|
|
gBankLoan = _s6.current_loan;
|
|
|
|
gParkFlags = _s6.park_flags;
|
|
|
|
gParkEntranceFee = _s6.park_entrance_fee;
|
|
|
|
// rct1_park_entrance_x
|
|
|
|
// rct1_park_entrance_y
|
|
|
|
// pad_013573EE
|
|
|
|
// rct1_park_entrance_z
|
|
|
|
memcpy(gPeepSpawns, _s6.peep_spawns, sizeof(_s6.peep_spawns));
|
|
|
|
gGuestChangeModifier = _s6.guest_count_change_modifier;
|
|
|
|
gResearchFundingLevel = _s6.current_research_level;
|
|
|
|
// pad_01357400
|
|
|
|
memcpy(gResearchedRideTypes, _s6.researched_ride_types, sizeof(_s6.researched_ride_types));
|
|
|
|
memcpy(gResearchedRideEntries, _s6.researched_ride_entries, sizeof(_s6.researched_ride_entries));
|
|
|
|
memcpy(gResearchedTrackTypesA, _s6.researched_track_types_a, sizeof(_s6.researched_track_types_a));
|
|
|
|
memcpy(gResearchedTrackTypesB, _s6.researched_track_types_b, sizeof(_s6.researched_track_types_b));
|
|
|
|
|
|
|
|
gNumGuestsInPark = _s6.guests_in_park;
|
|
|
|
gNumGuestsHeadingForPark = _s6.guests_heading_for_park;
|
|
|
|
|
|
|
|
memcpy(gExpenditureTable, _s6.expenditure_table, sizeof(_s6.expenditure_table));
|
|
|
|
|
|
|
|
gNumGuestsInParkLastWeek = _s6.last_guests_in_park;
|
|
|
|
// pad_01357BCA
|
|
|
|
gStaffHandymanColour = _s6.handyman_colour;
|
|
|
|
gStaffMechanicColour = _s6.mechanic_colour;
|
|
|
|
gStaffSecurityColour = _s6.security_colour;
|
|
|
|
|
|
|
|
memcpy(gResearchedSceneryItems, _s6.researched_scenery_items, sizeof(_s6.researched_scenery_items));
|
|
|
|
|
|
|
|
gParkRating = _s6.park_rating;
|
|
|
|
|
|
|
|
memcpy(gParkRatingHistory, _s6.park_rating_history, sizeof(_s6.park_rating_history));
|
|
|
|
memcpy(gGuestsInParkHistory, _s6.guests_in_park_history, sizeof(_s6.guests_in_park_history));
|
|
|
|
|
|
|
|
gResearchPriorities = _s6.active_research_types;
|
|
|
|
gResearchProgressStage = _s6.research_progress_stage;
|
|
|
|
gResearchLastItemSubject = _s6.last_researched_item_subject;
|
|
|
|
// pad_01357CF8
|
|
|
|
gResearchNextItem = _s6.next_research_item;
|
|
|
|
gResearchProgress = _s6.research_progress;
|
|
|
|
gResearchNextCategory = _s6.next_research_category;
|
|
|
|
gResearchExpectedDay = _s6.next_research_expected_day;
|
|
|
|
gResearchExpectedMonth = _s6.next_research_expected_month;
|
|
|
|
gGuestInitialHappiness = _s6.guest_initial_happiness;
|
|
|
|
gParkSize = _s6.park_size;
|
|
|
|
_guestGenerationProbability = _s6.guest_generation_probability;
|
|
|
|
gTotalRideValue = _s6.total_ride_value;
|
|
|
|
gMaxBankLoan = _s6.maximum_loan;
|
|
|
|
gGuestInitialCash = _s6.guest_initial_cash;
|
|
|
|
gGuestInitialHunger = _s6.guest_initial_hunger;
|
|
|
|
gGuestInitialThirst = _s6.guest_initial_thirst;
|
|
|
|
gScenarioObjectiveType = _s6.objective_type;
|
|
|
|
gScenarioObjectiveYear = _s6.objective_year;
|
|
|
|
// pad_013580FA
|
|
|
|
gScenarioObjectiveCurrency = _s6.objective_currency;
|
|
|
|
gScenarioObjectiveNumGuests = _s6.objective_guests;
|
|
|
|
memcpy(gMarketingCampaignDaysLeft, _s6.campaign_weeks_left, sizeof(_s6.campaign_weeks_left));
|
|
|
|
memcpy(gMarketingCampaignRideIndex, _s6.campaign_ride_index, sizeof(_s6.campaign_ride_index));
|
|
|
|
|
|
|
|
memcpy(gCashHistory, _s6.balance_history, sizeof(_s6.balance_history));
|
|
|
|
|
|
|
|
gCurrentExpenditure = _s6.current_expenditure;
|
|
|
|
gCurrentProfit = _s6.current_profit;
|
|
|
|
gWeeklyProfitAverageDividend = _s6.weekly_profit_average_dividend;
|
|
|
|
gWeeklyProfitAverageDivisor = _s6.weekly_profit_average_divisor;
|
|
|
|
// pad_0135833A
|
|
|
|
|
|
|
|
memcpy(gWeeklyProfitHistory, _s6.weekly_profit_history, sizeof(_s6.weekly_profit_history));
|
|
|
|
|
|
|
|
gParkValue = _s6.park_value;
|
|
|
|
|
|
|
|
memcpy(gParkValueHistory, _s6.park_value_history, sizeof(_s6.park_value_history));
|
|
|
|
|
|
|
|
gScenarioCompletedCompanyValue = _s6.completed_company_value;
|
|
|
|
gTotalAdmissions = _s6.total_admissions;
|
|
|
|
gTotalIncomeFromAdmissions = _s6.income_from_admissions;
|
|
|
|
gCompanyValue = _s6.company_value;
|
|
|
|
memcpy(gPeepWarningThrottle, _s6.peep_warning_throttle, sizeof(_s6.peep_warning_throttle));
|
|
|
|
|
|
|
|
// Awards
|
|
|
|
for (sint32 i = 0; i < RCT12_MAX_AWARDS; i++)
|
|
|
|
{
|
|
|
|
rct12_award * src = &_s6.awards[i];
|
|
|
|
Award * dst = &gCurrentAwards[i];
|
|
|
|
dst->Time = src->time;
|
|
|
|
dst->Type = src->type;
|
|
|
|
}
|
2016-05-07 17:20:10 +02:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
gLandPrice = _s6.land_price;
|
|
|
|
gConstructionRightsPrice = _s6.construction_rights_price;
|
|
|
|
// unk_01358774
|
|
|
|
// pad_01358776
|
|
|
|
// _s6.cd_key
|
|
|
|
_gameVersion = _s6.game_version_number;
|
|
|
|
gScenarioCompanyValueRecord = _s6.completed_company_value_record;
|
|
|
|
// _s6.loan_hash;
|
|
|
|
gRideCount = _s6.ride_count;
|
|
|
|
// pad_013587CA
|
|
|
|
gHistoricalProfit = _s6.historical_profit;
|
|
|
|
// pad_013587D4
|
|
|
|
memcpy(gScenarioCompletedBy, _s6.scenario_completed_name, sizeof(_s6.scenario_completed_name));
|
|
|
|
gCashEncrypted = _s6.cash;
|
|
|
|
// pad_013587FC
|
|
|
|
gParkRatingCasualtyPenalty = _s6.park_rating_casualty_penalty;
|
|
|
|
gMapSizeUnits = _s6.map_size_units;
|
|
|
|
gMapSizeMinus2 = _s6.map_size_minus_2;
|
|
|
|
gMapSize = _s6.map_size;
|
|
|
|
gMapSizeMaxXY = _s6.map_max_xy;
|
|
|
|
gSamePriceThroughoutParkA = _s6.same_price_throughout;
|
|
|
|
_suggestedGuestMaximum = _s6.suggested_max_guests;
|
|
|
|
gScenarioParkRatingWarningDays = _s6.park_rating_warning_days;
|
|
|
|
gLastEntranceStyle = _s6.last_entrance_style;
|
|
|
|
// rct1_water_colour
|
|
|
|
// pad_01358842
|
|
|
|
memcpy(gResearchItems, _s6.research_items, sizeof(_s6.research_items));
|
|
|
|
gMapBaseZ = _s6.map_base_z;
|
|
|
|
memcpy(gScenarioName, _s6.scenario_name, sizeof(_s6.scenario_name));
|
|
|
|
memcpy(gScenarioDetails, _s6.scenario_description, sizeof(_s6.scenario_description));
|
|
|
|
gBankLoanInterestRate = _s6.current_interest_rate;
|
|
|
|
// pad_0135934B
|
|
|
|
gSamePriceThroughoutParkB = _s6.same_price_throughout_extended;
|
2017-02-11 20:13:15 +01:00
|
|
|
// Preserve compatibility with vanilla RCT2's save format.
|
2017-02-11 19:51:19 +01:00
|
|
|
for (uint8 i = 0; i < RCT12_MAX_PARK_ENTRANCES; i++)
|
|
|
|
{
|
|
|
|
gParkEntrances[i].x = _s6.park_entrance_x[i];
|
|
|
|
gParkEntrances[i].y = _s6.park_entrance_y[i];
|
|
|
|
gParkEntrances[i].z = _s6.park_entrance_z[i];
|
|
|
|
gParkEntrances[i].direction = _s6.park_entrance_direction[i];
|
|
|
|
}
|
2017-01-31 00:56:10 +01:00
|
|
|
scenario_set_filename(_s6.scenario_filename);
|
|
|
|
memcpy(gScenarioExpansionPacks, _s6.saved_expansion_pack_names, sizeof(_s6.saved_expansion_pack_names));
|
|
|
|
memcpy(gBanners, _s6.banners, sizeof(_s6.banners));
|
|
|
|
memcpy(gUserStrings, _s6.custom_strings, sizeof(_s6.custom_strings));
|
|
|
|
gCurrentTicks = _s6.game_ticks_1;
|
|
|
|
memcpy(gRideList, _s6.rides, sizeof(_s6.rides));
|
|
|
|
gSavedAge = _s6.saved_age;
|
|
|
|
gSavedViewX = _s6.saved_view_x;
|
|
|
|
gSavedViewY = _s6.saved_view_y;
|
|
|
|
gSavedViewZoom = _s6.saved_view_zoom;
|
|
|
|
gSavedViewRotation = _s6.saved_view_rotation;
|
|
|
|
memcpy(gAnimatedObjects, _s6.map_animations, sizeof(_s6.map_animations));
|
|
|
|
gNumMapAnimations = _s6.num_map_animations;
|
|
|
|
// pad_0138B582
|
|
|
|
|
|
|
|
gRideRatingsCalcData = _s6.ride_ratings_calc_data;
|
|
|
|
memcpy(gRideMeasurements, _s6.ride_measurements, sizeof(_s6.ride_measurements));
|
|
|
|
gNextGuestNumber = _s6.next_guest_index;
|
|
|
|
gGrassSceneryTileLoopPosition = _s6.grass_and_scenery_tilepos;
|
|
|
|
memcpy(gStaffPatrolAreas, _s6.patrol_areas, sizeof(_s6.patrol_areas));
|
|
|
|
memcpy(gStaffModes, _s6.staff_modes, sizeof(_s6.staff_modes));
|
|
|
|
// unk_13CA73E
|
|
|
|
// pad_13CA73F
|
|
|
|
gUnk13CA740 = _s6.byte_13CA740;
|
|
|
|
gClimate = _s6.climate;
|
|
|
|
// pad_13CA741;
|
|
|
|
// byte_13CA742
|
|
|
|
// pad_013CA747
|
|
|
|
gClimateUpdateTimer = _s6.climate_update_timer;
|
|
|
|
gClimateCurrentWeather = _s6.current_weather;
|
|
|
|
gClimateNextWeather = _s6.next_weather;
|
|
|
|
gClimateCurrentTemperature = _s6.temperature;
|
|
|
|
gClimateNextTemperature = _s6.next_temperature;
|
|
|
|
gClimateCurrentWeatherEffect = _s6.current_weather_effect;
|
|
|
|
gClimateNextWeatherEffect = _s6.next_weather_effect;
|
|
|
|
gClimateCurrentWeatherGloom = _s6.current_weather_gloom;
|
|
|
|
gClimateNextWeatherGloom = _s6.next_weather_gloom;
|
|
|
|
gClimateCurrentRainLevel = _s6.current_rain_level;
|
|
|
|
gClimateNextRainLevel = _s6.next_rain_level;
|
|
|
|
|
|
|
|
// News items
|
|
|
|
for (size_t i = 0; i < RCT12_MAX_NEWS_ITEMS; i++)
|
|
|
|
{
|
|
|
|
const rct12_news_item * src = &_s6.news_items[i];
|
|
|
|
NewsItem * dst = &gNewsItems[i];
|
|
|
|
|
|
|
|
dst->Type = src->Type;
|
|
|
|
dst->Flags = src->Flags;
|
|
|
|
dst->Assoc = src->Assoc;
|
|
|
|
dst->Ticks = src->Ticks;
|
|
|
|
dst->MonthYear = src->MonthYear;
|
|
|
|
dst->Day = src->Day;
|
|
|
|
memcpy(dst->Text, src->Text, sizeof(src->Text));
|
|
|
|
}
|
2016-05-07 17:20:10 +02:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
// pad_13CE730
|
|
|
|
// rct1_scenario_flags
|
|
|
|
gWidePathTileLoopX = _s6.wide_path_tile_loop_x;
|
|
|
|
gWidePathTileLoopY = _s6.wide_path_tile_loop_y;
|
|
|
|
// pad_13CE778
|
2017-01-14 19:47:18 +01:00
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
// Fix and set dynamic variables
|
|
|
|
if (!object_load_entries(_s6.objects))
|
|
|
|
{
|
|
|
|
throw ObjectLoadException();
|
|
|
|
}
|
|
|
|
map_strip_ghost_flag_from_elements();
|
|
|
|
map_update_tile_pointers();
|
|
|
|
game_convert_strings_to_utf8();
|
|
|
|
map_count_remaining_land_rights();
|
2017-01-17 13:51:02 +01:00
|
|
|
}
|
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
void Initialise()
|
2016-05-08 18:21:55 +02:00
|
|
|
{
|
2017-01-31 00:56:10 +01:00
|
|
|
game_init_all(_s6.map_size);
|
2016-05-08 18:21:55 +02:00
|
|
|
}
|
2017-01-31 00:56:10 +01:00
|
|
|
};
|
2017-01-23 14:00:46 +01:00
|
|
|
|
2017-01-31 20:15:48 +01:00
|
|
|
IParkImporter * ParkImporter::CreateS6()
|
2017-01-31 19:37:55 +01:00
|
|
|
{
|
|
|
|
return new S6Importer();
|
|
|
|
}
|
|
|
|
|
2016-05-07 18:37:50 +02:00
|
|
|
extern "C"
|
|
|
|
{
|
2016-10-03 20:14:26 +02:00
|
|
|
bool game_load_sv6_path(const char * path)
|
|
|
|
{
|
|
|
|
bool result = false;
|
|
|
|
auto s6Importer = new S6Importer();
|
|
|
|
try
|
|
|
|
{
|
|
|
|
s6Importer->LoadSavedGame(path);
|
|
|
|
s6Importer->Import();
|
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
game_fix_save_vars();
|
2016-12-11 01:08:37 +01:00
|
|
|
sprite_position_tween_reset();
|
2016-10-03 20:14:26 +02:00
|
|
|
result = true;
|
|
|
|
}
|
2016-11-30 23:32:47 +01:00
|
|
|
catch (const ObjectLoadException &)
|
2016-10-03 20:14:26 +02:00
|
|
|
{
|
|
|
|
gErrorType = ERROR_TYPE_FILE_LOAD;
|
|
|
|
gErrorStringId = STR_GAME_SAVE_FAILED;
|
|
|
|
}
|
2016-11-30 23:32:47 +01:00
|
|
|
catch (const IOException &)
|
2016-10-03 20:14:26 +02:00
|
|
|
{
|
|
|
|
gErrorType = ERROR_TYPE_FILE_LOAD;
|
|
|
|
gErrorStringId = STR_GAME_SAVE_FAILED;
|
|
|
|
}
|
2016-11-30 23:32:47 +01:00
|
|
|
catch (const Exception &)
|
2016-10-03 20:14:26 +02:00
|
|
|
{
|
|
|
|
gErrorType = ERROR_TYPE_FILE_LOAD;
|
|
|
|
gErrorStringId = STR_FILE_CONTAINS_INVALID_DATA;
|
|
|
|
}
|
|
|
|
delete s6Importer;
|
|
|
|
|
|
|
|
gScreenAge = 0;
|
2016-12-19 22:08:19 +01:00
|
|
|
gLastAutoSaveUpdate = AUTOSAVE_PAUSE;
|
2016-10-03 20:14:26 +02:00
|
|
|
return result;
|
2016-05-07 18:37:50 +02:00
|
|
|
}
|
2016-05-07 23:47:29 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
*
|
|
|
|
* rct2: 0x00676053
|
|
|
|
* scenario (ebx)
|
|
|
|
*/
|
2017-01-04 22:17:08 +01:00
|
|
|
sint32 scenario_load(const char * path)
|
2016-05-07 23:47:29 +02:00
|
|
|
{
|
|
|
|
bool result = false;
|
|
|
|
auto s6Importer = new S6Importer();
|
|
|
|
try
|
|
|
|
{
|
|
|
|
s6Importer->LoadScenario(path);
|
|
|
|
s6Importer->Import();
|
|
|
|
|
2017-01-31 00:56:10 +01:00
|
|
|
game_fix_save_vars();
|
2016-12-11 01:08:37 +01:00
|
|
|
sprite_position_tween_reset();
|
2016-05-07 23:47:29 +02:00
|
|
|
result = true;
|
|
|
|
}
|
2016-11-30 23:32:47 +01:00
|
|
|
catch (const ObjectLoadException &)
|
2016-05-07 23:47:29 +02:00
|
|
|
{
|
2016-07-09 16:36:48 +02:00
|
|
|
gErrorType = ERROR_TYPE_FILE_LOAD;
|
|
|
|
gErrorStringId = STR_GAME_SAVE_FAILED;
|
2016-05-07 23:47:29 +02:00
|
|
|
}
|
2016-11-30 23:32:47 +01:00
|
|
|
catch (const IOException &)
|
2016-05-07 23:47:29 +02:00
|
|
|
{
|
|
|
|
gErrorType = ERROR_TYPE_FILE_LOAD;
|
2016-05-08 02:22:32 +02:00
|
|
|
gErrorStringId = STR_GAME_SAVE_FAILED;
|
2016-05-07 23:47:29 +02:00
|
|
|
}
|
2016-11-30 23:32:47 +01:00
|
|
|
catch (const Exception &)
|
2016-05-07 23:47:29 +02:00
|
|
|
{
|
|
|
|
gErrorType = ERROR_TYPE_FILE_LOAD;
|
|
|
|
gErrorStringId = STR_FILE_CONTAINS_INVALID_DATA;
|
|
|
|
}
|
|
|
|
delete s6Importer;
|
|
|
|
|
|
|
|
gScreenAge = 0;
|
2016-12-19 22:08:19 +01:00
|
|
|
gLastAutoSaveUpdate = AUTOSAVE_PAUSE;
|
2016-05-07 23:47:29 +02:00
|
|
|
return result;
|
|
|
|
}
|
2016-05-07 14:58:36 +02:00
|
|
|
}
|