2017-06-01 21:55:10 +02:00
|
|
|
#pragma region Copyright (c) 2014-2017 OpenRCT2 Developers
|
2016-10-12 13:36:30 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* 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
|
|
|
|
|
|
|
|
#include <algorithm>
|
|
|
|
#include <memory>
|
|
|
|
#include <vector>
|
2016-12-14 13:13:52 +01:00
|
|
|
#include "../core/Console.hpp"
|
2017-07-31 00:06:22 +02:00
|
|
|
#include "../core/File.h"
|
2016-12-14 13:13:52 +01:00
|
|
|
#include "../core/FileScanner.h"
|
|
|
|
#include "../core/FileStream.hpp"
|
|
|
|
#include "../core/Math.hpp"
|
|
|
|
#include "../core/Path.hpp"
|
|
|
|
#include "../core/String.hpp"
|
2016-12-26 23:42:19 +01:00
|
|
|
#include "../core/Util.hpp"
|
2017-01-31 00:08:04 +01:00
|
|
|
#include "../ParkImporter.h"
|
2016-12-14 13:13:52 +01:00
|
|
|
#include "../PlatformEnvironment.h"
|
2017-02-05 13:18:07 +01:00
|
|
|
#include "../rct12/SawyerChunkReader.h"
|
2016-10-12 13:36:30 +02:00
|
|
|
#include "ScenarioRepository.h"
|
|
|
|
#include "ScenarioSources.h"
|
|
|
|
|
|
|
|
extern "C"
|
|
|
|
{
|
2017-02-18 16:45:10 +01:00
|
|
|
#include "../config/Config.h"
|
2016-12-14 13:13:52 +01:00
|
|
|
#include "../localisation/localisation.h"
|
2017-02-18 16:45:10 +01:00
|
|
|
#include "../platform/platform.h"
|
2016-10-12 13:36:30 +02:00
|
|
|
#include "scenario.h"
|
|
|
|
}
|
|
|
|
|
2017-06-11 13:53:37 +02:00
|
|
|
using namespace OpenRCT2;
|
|
|
|
|
2017-08-26 19:19:30 +02:00
|
|
|
constexpr uint32 SCENARIO_REPOSITORY_MAGIC_NUMBER = 0x58444953;
|
|
|
|
constexpr uint16 SCENARIO_REPOSITORY_VERSION = 1;
|
|
|
|
|
|
|
|
struct ScenarioRepositoryHeader
|
|
|
|
{
|
|
|
|
uint32 MagicNumber;
|
|
|
|
uint16 Version;
|
|
|
|
uint32 TotalFiles;
|
|
|
|
uint64 TotalFileSize;
|
|
|
|
uint32 FileDateModifiedChecksum;
|
|
|
|
uint32 PathChecksum;
|
|
|
|
uint32 NumItems;
|
|
|
|
};
|
|
|
|
|
2017-01-04 22:17:08 +01:00
|
|
|
static sint32 ScenarioCategoryCompare(sint32 categoryA, sint32 categoryB)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
if (categoryA == categoryB) return 0;
|
|
|
|
if (categoryA == SCENARIO_CATEGORY_DLC) return -1;
|
|
|
|
if (categoryB == SCENARIO_CATEGORY_DLC) return 1;
|
|
|
|
if (categoryA == SCENARIO_CATEGORY_BUILD_YOUR_OWN) return -1;
|
|
|
|
if (categoryB == SCENARIO_CATEGORY_BUILD_YOUR_OWN) return 1;
|
|
|
|
return Math::Sign(categoryA - categoryB);
|
|
|
|
}
|
|
|
|
|
2017-01-04 22:17:08 +01:00
|
|
|
static sint32 scenario_index_entry_CompareByCategory(const scenario_index_entry &entryA,
|
2016-10-12 13:36:30 +02:00
|
|
|
const scenario_index_entry &entryB)
|
|
|
|
{
|
|
|
|
// Order by category
|
|
|
|
if (entryA.category != entryB.category)
|
|
|
|
{
|
|
|
|
return ScenarioCategoryCompare(entryA.category, entryB.category);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Then by source game / name
|
|
|
|
switch (entryA.category) {
|
|
|
|
default:
|
|
|
|
if (entryA.source_game != entryB.source_game)
|
|
|
|
{
|
|
|
|
return entryA.source_game - entryB.source_game;
|
|
|
|
}
|
|
|
|
return strcmp(entryA.name, entryB.name);
|
|
|
|
case SCENARIO_CATEGORY_REAL:
|
|
|
|
case SCENARIO_CATEGORY_OTHER:
|
|
|
|
return strcmp(entryA.name, entryB.name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-04 22:17:08 +01:00
|
|
|
static sint32 scenario_index_entry_CompareByIndex(const scenario_index_entry &entryA,
|
2016-10-12 13:36:30 +02:00
|
|
|
const scenario_index_entry &entryB)
|
|
|
|
{
|
|
|
|
// Order by source game
|
|
|
|
if (entryA.source_game != entryB.source_game)
|
|
|
|
{
|
|
|
|
return entryA.source_game - entryB.source_game;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Then by index / category / name
|
|
|
|
uint8 sourceGame = entryA.source_game;
|
|
|
|
switch (sourceGame) {
|
|
|
|
default:
|
|
|
|
if (entryA.source_index == -1 && entryB.source_index == -1)
|
|
|
|
{
|
|
|
|
if (entryA.category == entryB.category)
|
|
|
|
{
|
|
|
|
return scenario_index_entry_CompareByCategory(entryA, entryB);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return ScenarioCategoryCompare(entryA.category, entryB.category);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (entryA.source_index == -1)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
else if (entryB.source_index == -1)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return entryA.source_index - entryB.source_index;
|
|
|
|
}
|
|
|
|
case SCENARIO_SOURCE_REAL:
|
|
|
|
return scenario_index_entry_CompareByCategory(entryA, entryB);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void scenario_highscore_free(scenario_highscore_entry * highscore)
|
|
|
|
{
|
|
|
|
SafeFree(highscore->fileName);
|
|
|
|
SafeFree(highscore->name);
|
|
|
|
SafeDelete(highscore);
|
|
|
|
}
|
|
|
|
|
|
|
|
class ScenarioRepository final : public IScenarioRepository
|
|
|
|
{
|
|
|
|
private:
|
2017-08-26 19:19:30 +02:00
|
|
|
static constexpr const utf8 * SC_FILE_PATTERN = "*.sc4;*.sc6";
|
2016-10-12 13:36:30 +02:00
|
|
|
static constexpr uint32 HighscoreFileVersion = 1;
|
|
|
|
|
2016-12-10 20:20:32 +01:00
|
|
|
IPlatformEnvironment * _env;
|
2016-10-12 13:36:30 +02:00
|
|
|
std::vector<scenario_index_entry> _scenarios;
|
|
|
|
std::vector<scenario_highscore_entry*> _highscores;
|
2017-08-26 19:19:30 +02:00
|
|
|
QueryDirectoryResult _directoryQueryResult = { 0 };
|
2016-10-12 13:36:30 +02:00
|
|
|
|
|
|
|
public:
|
2016-12-10 20:20:32 +01:00
|
|
|
ScenarioRepository(IPlatformEnvironment * env)
|
|
|
|
{
|
|
|
|
_env = env;
|
|
|
|
}
|
|
|
|
|
2016-10-12 13:36:30 +02:00
|
|
|
virtual ~ScenarioRepository()
|
|
|
|
{
|
|
|
|
ClearHighscores();
|
|
|
|
}
|
|
|
|
|
2016-10-13 00:54:06 +02:00
|
|
|
void Scan() override
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
_scenarios.clear();
|
|
|
|
|
|
|
|
// Scan RCT2 directory
|
2017-01-30 19:55:17 +01:00
|
|
|
std::string rct1dir = _env->GetDirectoryPath(DIRBASE::RCT1, DIRID::SCENARIO);
|
2016-12-10 20:20:32 +01:00
|
|
|
std::string rct2dir = _env->GetDirectoryPath(DIRBASE::RCT2, DIRID::SCENARIO);
|
2016-12-12 03:06:20 +01:00
|
|
|
std::string openrct2dir = _env->GetDirectoryPath(DIRBASE::USER, DIRID::SCENARIO);
|
2017-07-31 00:06:22 +02:00
|
|
|
std::string mpdatdir = _env->GetFilePath(PATHID::MP_DAT);
|
|
|
|
|
2017-08-26 19:19:30 +02:00
|
|
|
_directoryQueryResult = { 0 };
|
|
|
|
Query(rct1dir);
|
|
|
|
Query(rct2dir);
|
|
|
|
Query(openrct2dir);
|
|
|
|
|
|
|
|
if (!Load())
|
|
|
|
{
|
|
|
|
Scan(rct1dir);
|
|
|
|
Scan(rct2dir);
|
|
|
|
Scan(openrct2dir);
|
|
|
|
Save();
|
|
|
|
}
|
2016-10-12 13:36:30 +02:00
|
|
|
|
2017-07-31 00:06:22 +02:00
|
|
|
ConvertMegaPark(mpdatdir, openrct2dir);
|
|
|
|
|
2016-10-12 13:36:30 +02:00
|
|
|
Sort();
|
2017-08-26 19:19:30 +02:00
|
|
|
|
2016-10-12 13:36:30 +02:00
|
|
|
LoadScores();
|
|
|
|
LoadLegacyScores();
|
|
|
|
AttachHighscores();
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t GetCount() const override
|
|
|
|
{
|
|
|
|
return _scenarios.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
const scenario_index_entry * GetByIndex(size_t index) const override
|
|
|
|
{
|
|
|
|
const scenario_index_entry * result = nullptr;
|
|
|
|
if (index < _scenarios.size())
|
|
|
|
{
|
|
|
|
result = &_scenarios[index];
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
const scenario_index_entry * GetByFilename(const utf8 * filename) const override
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < _scenarios.size(); i++)
|
|
|
|
{
|
|
|
|
const scenario_index_entry * scenario = &_scenarios[i];
|
|
|
|
const utf8 * scenarioFilename = Path::GetFileName(scenario->path);
|
|
|
|
|
|
|
|
// Note: this is always case insensitive search for cross platform consistency
|
|
|
|
if (String::Equals(filename, scenarioFilename, true))
|
|
|
|
{
|
|
|
|
return &_scenarios[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
const scenario_index_entry * GetByPath(const utf8 * path) const override
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < _scenarios.size(); i++)
|
|
|
|
{
|
|
|
|
const scenario_index_entry * scenario = &_scenarios[i];
|
|
|
|
if (Path::Equals(path, scenario->path))
|
|
|
|
{
|
|
|
|
return scenario;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TryRecordHighscore(const utf8 * scenarioFileName, money32 companyValue, const utf8 * name) override
|
|
|
|
{
|
2017-01-02 00:31:24 +01:00
|
|
|
// Scan the scenarios so we have a fresh list to query. This is to prevent the issue of scenario completions
|
|
|
|
// not getting recorded, see #4951.
|
|
|
|
Scan();
|
|
|
|
|
2016-10-14 01:01:34 +02:00
|
|
|
scenario_index_entry * scenario = GetByFilename(scenarioFileName);
|
2016-10-12 13:36:30 +02:00
|
|
|
if (scenario != nullptr)
|
|
|
|
{
|
|
|
|
// Check if record company value has been broken or the highscore is the same but no name is registered
|
|
|
|
scenario_highscore_entry * highscore = scenario->highscore;
|
|
|
|
if (highscore == nullptr || companyValue > highscore->company_value ||
|
2017-01-02 01:28:14 +01:00
|
|
|
(String::IsNullOrEmpty(highscore->name) && companyValue == highscore->company_value))
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
if (highscore == nullptr)
|
|
|
|
{
|
|
|
|
highscore = InsertHighscore();
|
2016-10-14 01:01:34 +02:00
|
|
|
highscore->timestamp = platform_get_datetime_now_utc();
|
|
|
|
scenario->highscore = highscore;
|
2016-10-12 13:36:30 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-01-02 01:28:14 +01:00
|
|
|
if (!String::IsNullOrEmpty(highscore->name))
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
2016-10-14 01:01:34 +02:00
|
|
|
highscore->timestamp = platform_get_datetime_now_utc();
|
2016-10-12 13:36:30 +02:00
|
|
|
}
|
|
|
|
SafeFree(highscore->fileName);
|
|
|
|
SafeFree(highscore->name);
|
|
|
|
}
|
2016-10-14 01:01:34 +02:00
|
|
|
highscore->fileName = String::Duplicate(Path::GetFileName(scenario->path));
|
|
|
|
highscore->name = String::Duplicate(name);
|
|
|
|
highscore->company_value = companyValue;
|
2016-10-12 13:36:30 +02:00
|
|
|
SaveHighscores();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
scenario_index_entry * GetByFilename(const utf8 * filename)
|
|
|
|
{
|
|
|
|
const ScenarioRepository * repo = this;
|
|
|
|
return (scenario_index_entry *)repo->GetByFilename(filename);
|
|
|
|
}
|
|
|
|
|
|
|
|
scenario_index_entry * GetByPath(const utf8 * path)
|
|
|
|
{
|
|
|
|
const ScenarioRepository * repo = this;
|
|
|
|
return (scenario_index_entry *)repo->GetByPath(path);
|
|
|
|
}
|
|
|
|
|
2017-08-26 19:19:30 +02:00
|
|
|
void Query(const std::string &directory)
|
|
|
|
{
|
|
|
|
std::string pattern = Path::Combine(directory, SC_FILE_PATTERN);
|
|
|
|
Path::QueryDirectory(&_directoryQueryResult, pattern);
|
|
|
|
}
|
|
|
|
|
2016-12-10 20:20:32 +01:00
|
|
|
void Scan(const std::string &directory)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
utf8 pattern[MAX_PATH];
|
2016-12-10 20:20:32 +01:00
|
|
|
String::Set(pattern, sizeof(pattern), directory.c_str());
|
2017-08-26 19:19:30 +02:00
|
|
|
Path::Append(pattern, sizeof(pattern), SC_FILE_PATTERN);
|
2016-10-12 13:36:30 +02:00
|
|
|
|
2016-10-22 20:10:16 +02:00
|
|
|
IFileScanner * scanner = Path::ScanDirectory(pattern, true);
|
|
|
|
while (scanner->Next())
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
2016-10-22 20:10:16 +02:00
|
|
|
auto path = scanner->GetPath();
|
|
|
|
auto fileInfo = scanner->GetFileInfo();
|
2016-10-22 23:05:06 +02:00
|
|
|
AddScenario(path, fileInfo->LastModified);
|
2016-10-12 13:36:30 +02:00
|
|
|
}
|
2016-10-22 20:10:16 +02:00
|
|
|
delete scanner;
|
2016-10-12 13:36:30 +02:00
|
|
|
}
|
|
|
|
|
2017-07-31 00:06:22 +02:00
|
|
|
void ConvertMegaPark(std::string &mpdatDir, std::string &scenarioDir)
|
|
|
|
{
|
|
|
|
//Convert mp.dat from RCT1 Data directory into SC21.SC4 (Mega Park)
|
|
|
|
utf8 mpdatPath[MAX_PATH];
|
|
|
|
utf8 sc21Path[MAX_PATH];
|
|
|
|
|
|
|
|
String::Set(mpdatPath, sizeof(mpdatPath), mpdatDir.c_str());
|
|
|
|
|
|
|
|
if (platform_file_exists(mpdatPath))
|
|
|
|
{
|
|
|
|
//Make sure the scenario directory exists, and that SC21.SC4 hasn't already been created
|
|
|
|
String::Set(sc21Path, sizeof(sc21Path), scenarioDir.c_str());
|
|
|
|
platform_ensure_directory_exists(sc21Path);
|
|
|
|
Path::Append(sc21Path, sizeof(sc21Path), "SC21.SC4");
|
|
|
|
|
|
|
|
if (!platform_file_exists(sc21Path)) {
|
|
|
|
size_t length;
|
|
|
|
auto mpdat = (uint8 *)(File::ReadAllBytes(mpdatPath, &length));
|
|
|
|
auto outFS = FileStream(sc21Path, FILE_MODE_WRITE);
|
|
|
|
|
|
|
|
for (uint32 i = 0; i < (uint32)length; i++)
|
|
|
|
{
|
|
|
|
//Rotate each byte of mp.dat left by 4 bits to convert
|
|
|
|
mpdat[i] = rol8(mpdat[i], 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
outFS.WriteArray<uint8>(mpdat, length);
|
|
|
|
Memory::FreeArray(mpdat, length);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-30 19:55:17 +01:00
|
|
|
void AddScenario(const std::string &path, uint64 timestamp)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
2017-01-30 22:32:58 +01:00
|
|
|
scenario_index_entry entry;
|
|
|
|
if (!GetScenarioInfo(path, timestamp, &entry))
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-01-30 19:55:17 +01:00
|
|
|
const std::string filename = Path::GetFileName(path);
|
|
|
|
scenario_index_entry * existingEntry = GetByFilename(filename.c_str());
|
2016-10-12 13:36:30 +02:00
|
|
|
if (existingEntry != nullptr)
|
|
|
|
{
|
2017-01-30 19:55:17 +01:00
|
|
|
std::string conflictPath;
|
2016-10-12 13:36:30 +02:00
|
|
|
if (existingEntry->timestamp > timestamp)
|
|
|
|
{
|
|
|
|
// Existing entry is more recent
|
2017-01-30 19:55:17 +01:00
|
|
|
conflictPath = String::ToStd(existingEntry->path);
|
2016-10-12 13:36:30 +02:00
|
|
|
|
|
|
|
// Overwrite existing entry with this one
|
2017-01-30 22:32:58 +01:00
|
|
|
*existingEntry = entry;
|
2016-10-12 13:36:30 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// This entry is more recent
|
|
|
|
conflictPath = path;
|
|
|
|
}
|
2017-01-30 19:55:17 +01:00
|
|
|
Console::WriteLine("Scenario conflict: '%s' ignored because it is newer.", conflictPath.c_str());
|
2016-10-12 13:36:30 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_scenarios.push_back(entry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-30 19:55:17 +01:00
|
|
|
/**
|
|
|
|
* Reads basic information from a scenario file.
|
|
|
|
*/
|
2017-01-30 22:32:58 +01:00
|
|
|
bool GetScenarioInfo(const std::string &path, uint64 timestamp, scenario_index_entry * entry)
|
2017-01-30 19:55:17 +01:00
|
|
|
{
|
2017-01-31 20:15:48 +01:00
|
|
|
log_verbose("GetScenarioInfo(%s, %d, ...)", path.c_str(), timestamp);
|
2017-01-30 19:55:17 +01:00
|
|
|
try
|
|
|
|
{
|
|
|
|
std::string extension = Path::GetExtension(path);
|
|
|
|
if (String::Equals(extension, ".sc4", true))
|
|
|
|
{
|
|
|
|
// RCT1 scenario
|
2017-01-30 22:32:58 +01:00
|
|
|
bool result = false;
|
2017-01-30 23:58:48 +01:00
|
|
|
try
|
|
|
|
{
|
2017-01-31 20:15:48 +01:00
|
|
|
auto s4Importer = std::unique_ptr<IParkImporter>(ParkImporter::CreateS4());
|
2017-06-30 01:37:41 +02:00
|
|
|
s4Importer->LoadScenario(path.c_str(), true);
|
2017-01-30 23:58:48 +01:00
|
|
|
if (s4Importer->GetDetails(entry))
|
|
|
|
{
|
|
|
|
String::Set(entry->path, sizeof(entry->path), path.c_str());
|
|
|
|
entry->timestamp = timestamp;
|
|
|
|
result = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (Exception)
|
2017-01-30 22:32:58 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
return result;
|
2017-01-30 19:55:17 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// RCT2 scenario
|
2017-01-30 22:32:58 +01:00
|
|
|
auto fs = FileStream(path, FILE_MODE_OPEN);
|
2017-02-05 13:18:07 +01:00
|
|
|
auto chunkReader = SawyerChunkReader(&fs);
|
|
|
|
|
|
|
|
rct_s6_header header = chunkReader.ReadChunkAs<rct_s6_header>();
|
|
|
|
if (header.type == S6_TYPE_SCENARIO)
|
2017-01-30 19:55:17 +01:00
|
|
|
{
|
2017-02-05 13:18:07 +01:00
|
|
|
rct_s6_info info = chunkReader.ReadChunkAs<rct_s6_info>();
|
|
|
|
*entry = CreateNewScenarioEntry(path, timestamp, &info);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
log_verbose("%s is not a scenario", path.c_str());
|
2017-01-30 19:55:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (Exception)
|
|
|
|
{
|
2017-01-31 18:59:42 +01:00
|
|
|
Console::Error::WriteLine("Unable to read scenario: '%s'", path.c_str());
|
2017-01-30 19:55:17 +01:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-01-30 22:32:58 +01:00
|
|
|
scenario_index_entry CreateNewScenarioEntry(const std::string &path, uint64 timestamp, rct_s6_info * s6Info)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
scenario_index_entry entry = { 0 };
|
|
|
|
|
|
|
|
// Set new entry
|
2017-01-30 22:32:58 +01:00
|
|
|
String::Set(entry.path, sizeof(entry.path), path.c_str());
|
2016-10-12 13:36:30 +02:00
|
|
|
entry.timestamp = timestamp;
|
|
|
|
entry.category = s6Info->category;
|
|
|
|
entry.objective_type = s6Info->objective_type;
|
|
|
|
entry.objective_arg_1 = s6Info->objective_arg_1;
|
|
|
|
entry.objective_arg_2 = s6Info->objective_arg_2;
|
|
|
|
entry.objective_arg_3 = s6Info->objective_arg_3;
|
|
|
|
entry.highscore = nullptr;
|
2017-08-19 07:49:35 +02:00
|
|
|
if (String::IsNullOrEmpty(s6Info->name))
|
|
|
|
{
|
|
|
|
// If the scenario doesn't have a name, set it to the filename
|
|
|
|
String::Set(entry.name, sizeof(entry.name), Path::GetFileNameWithoutExtension(entry.path));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
String::Set(entry.name, sizeof(entry.name), s6Info->name);
|
|
|
|
// Normalise the name to make the scenario as recognisable as possible.
|
|
|
|
ScenarioSources::NormaliseName(entry.name, sizeof(entry.name), entry.name);
|
|
|
|
}
|
2016-10-12 13:36:30 +02:00
|
|
|
|
2017-08-19 07:49:35 +02:00
|
|
|
String::Set(entry.details, sizeof(entry.details), s6Info->details);
|
2016-10-12 13:36:30 +02:00
|
|
|
|
|
|
|
// Look up and store information regarding the origins of this scenario.
|
|
|
|
source_desc desc;
|
|
|
|
if (ScenarioSources::TryGetByName(entry.name, &desc))
|
|
|
|
{
|
|
|
|
entry.sc_id = desc.id;
|
|
|
|
entry.source_index = desc.index;
|
|
|
|
entry.source_game = desc.source;
|
|
|
|
entry.category = desc.category;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
entry.sc_id = SC_UNIDENTIFIED;
|
|
|
|
entry.source_index = -1;
|
|
|
|
if (entry.category == SCENARIO_CATEGORY_REAL)
|
|
|
|
{
|
|
|
|
entry.source_game = SCENARIO_SOURCE_REAL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
entry.source_game = SCENARIO_SOURCE_OTHER;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
scenario_translate(&entry, &s6Info->entry);
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Sort()
|
|
|
|
{
|
|
|
|
if (gConfigGeneral.scenario_select_mode == SCENARIO_SELECT_MODE_ORIGIN)
|
|
|
|
{
|
|
|
|
std::sort(_scenarios.begin(), _scenarios.end(), [](const scenario_index_entry &a,
|
|
|
|
const scenario_index_entry &b) -> bool
|
|
|
|
{
|
|
|
|
return scenario_index_entry_CompareByIndex(a, b) < 0;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
std::sort(_scenarios.begin(), _scenarios.end(), [](const scenario_index_entry &a,
|
|
|
|
const scenario_index_entry &b) -> bool
|
|
|
|
{
|
|
|
|
return scenario_index_entry_CompareByCategory(a, b) < 0;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-26 19:19:30 +02:00
|
|
|
bool Load()
|
|
|
|
{
|
|
|
|
std::string path = _env->GetFilePath(PATHID::CACHE_SCENARIOS);
|
|
|
|
bool result = false;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
auto fs = FileStream(path, FILE_MODE_OPEN);
|
|
|
|
|
|
|
|
// Read header, check if we need to re-scan
|
|
|
|
auto header = fs.ReadValue<ScenarioRepositoryHeader>();
|
|
|
|
if (header.MagicNumber == SCENARIO_REPOSITORY_MAGIC_NUMBER &&
|
|
|
|
header.Version == SCENARIO_REPOSITORY_VERSION &&
|
|
|
|
header.TotalFiles == _directoryQueryResult.TotalFiles &&
|
|
|
|
header.TotalFileSize == _directoryQueryResult.TotalFileSize &&
|
|
|
|
header.FileDateModifiedChecksum == _directoryQueryResult.FileDateModifiedChecksum &&
|
|
|
|
header.PathChecksum == _directoryQueryResult.PathChecksum)
|
|
|
|
{
|
|
|
|
// Directory is the same, just read the saved items
|
|
|
|
for (uint32 i = 0; i < header.NumItems; i++)
|
|
|
|
{
|
|
|
|
auto scenario = fs.ReadValue<scenario_index_entry>();
|
|
|
|
_scenarios.push_back(scenario);
|
|
|
|
}
|
|
|
|
result = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (const Exception &)
|
|
|
|
{
|
|
|
|
Console::Error::WriteLine("Unable to load scenario repository index.");
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Save() const
|
|
|
|
{
|
|
|
|
std::string path = _env->GetFilePath(PATHID::CACHE_SCENARIOS);
|
|
|
|
try
|
|
|
|
{
|
|
|
|
auto fs = FileStream(path, FILE_MODE_WRITE);
|
|
|
|
|
|
|
|
// Write header
|
|
|
|
ScenarioRepositoryHeader header = { 0 };
|
|
|
|
header.MagicNumber = SCENARIO_REPOSITORY_MAGIC_NUMBER;
|
|
|
|
header.Version = SCENARIO_REPOSITORY_VERSION;
|
|
|
|
header.TotalFiles = _directoryQueryResult.TotalFiles;
|
|
|
|
header.TotalFileSize = _directoryQueryResult.TotalFileSize;
|
|
|
|
header.FileDateModifiedChecksum = _directoryQueryResult.FileDateModifiedChecksum;
|
|
|
|
header.PathChecksum = _directoryQueryResult.PathChecksum;
|
|
|
|
header.NumItems = (uint32)_scenarios.size();
|
|
|
|
fs.WriteValue(header);
|
|
|
|
|
|
|
|
// Write items
|
|
|
|
for (const auto scenario : _scenarios)
|
|
|
|
{
|
|
|
|
fs.WriteValue(scenario);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (const Exception &)
|
|
|
|
{
|
|
|
|
Console::Error::WriteLine("Unable to write scenario repository index.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-12 13:36:30 +02:00
|
|
|
void LoadScores()
|
|
|
|
{
|
2016-12-10 20:20:32 +01:00
|
|
|
std::string path = _env->GetFilePath(PATHID::SCORES);
|
|
|
|
if (!platform_file_exists(path.c_str()))
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
2016-12-10 20:20:32 +01:00
|
|
|
auto fs = FileStream(path, FILE_MODE_OPEN);
|
2016-10-12 13:36:30 +02:00
|
|
|
uint32 fileVersion = fs.ReadValue<uint32>();
|
|
|
|
if (fileVersion != 1)
|
|
|
|
{
|
|
|
|
Console::Error::WriteLine("Invalid or incompatible highscores file.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ClearHighscores();
|
|
|
|
|
|
|
|
uint32 numHighscores = fs.ReadValue<uint32>();
|
2016-10-13 00:54:06 +02:00
|
|
|
for (uint32 i = 0; i < numHighscores; i++)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
scenario_highscore_entry * highscore = InsertHighscore();
|
|
|
|
highscore->fileName = fs.ReadString();
|
|
|
|
highscore->name = fs.ReadString();
|
|
|
|
highscore->company_value = fs.ReadValue<money32>();
|
|
|
|
highscore->timestamp = fs.ReadValue<datetime64>();
|
|
|
|
}
|
|
|
|
}
|
2016-11-30 23:32:47 +01:00
|
|
|
catch (const Exception &)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
Console::Error::WriteLine("Error reading highscores.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Loads the original scores.dat file and replaces any highscores that
|
|
|
|
* are better for matching scenarios.
|
|
|
|
*/
|
|
|
|
void LoadLegacyScores()
|
|
|
|
{
|
2016-12-10 20:20:32 +01:00
|
|
|
std::string rct2Path = _env->GetFilePath(PATHID::SCORES_RCT2);
|
|
|
|
std::string legacyPath = _env->GetFilePath(PATHID::SCORES_LEGACY);
|
|
|
|
LoadLegacyScores(legacyPath);
|
|
|
|
LoadLegacyScores(rct2Path);
|
2016-10-12 13:36:30 +02:00
|
|
|
}
|
|
|
|
|
2016-12-10 20:20:32 +01:00
|
|
|
void LoadLegacyScores(const std::string &path)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
2016-12-10 20:20:32 +01:00
|
|
|
if (!platform_file_exists(path.c_str()))
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool highscoresDirty = false;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
auto fs = FileStream(path, FILE_MODE_OPEN);
|
|
|
|
if (fs.GetLength() <= 4)
|
|
|
|
{
|
|
|
|
// Initial value of scores for RCT2, just ignore
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Load header
|
2017-01-17 13:21:57 +01:00
|
|
|
auto header = fs.ReadValue<rct_scores_header>();
|
|
|
|
for (uint32 i = 0; i < header.ScenarioCount; i++)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
// Read legacy entry
|
2017-01-17 13:21:57 +01:00
|
|
|
auto scBasic = fs.ReadValue<rct_scores_entry>();
|
2016-10-12 13:36:30 +02:00
|
|
|
|
|
|
|
// Ignore non-completed scenarios
|
2017-01-17 13:21:57 +01:00
|
|
|
if (scBasic.Flags & SCENARIO_FLAGS_COMPLETED)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
bool notFound = true;
|
2017-01-12 19:02:28 +01:00
|
|
|
for (size_t j = 0; j < _highscores.size(); j++)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
2017-01-12 19:02:28 +01:00
|
|
|
scenario_highscore_entry * highscore = _highscores[j];
|
2017-01-17 13:21:57 +01:00
|
|
|
if (String::Equals(scBasic.Path, highscore->fileName, true))
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
notFound = false;
|
|
|
|
|
|
|
|
// Check if legacy highscore is better
|
2017-01-17 13:21:57 +01:00
|
|
|
if (scBasic.CompanyValue > highscore->company_value)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
|
|
|
SafeFree(highscore->name);
|
2017-01-17 13:21:57 +01:00
|
|
|
highscore->name = win1252_to_utf8_alloc(scBasic.CompletedBy, Util::CountOf(scBasic.CompletedBy));
|
|
|
|
highscore->company_value = scBasic.CompanyValue;
|
2016-10-12 13:36:30 +02:00
|
|
|
highscore->timestamp = DATETIME64_MIN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (notFound)
|
|
|
|
{
|
|
|
|
scenario_highscore_entry * highscore = InsertHighscore();
|
2017-01-17 13:21:57 +01:00
|
|
|
highscore->fileName = String::Duplicate(scBasic.Path);
|
|
|
|
highscore->name = win1252_to_utf8_alloc(scBasic.CompletedBy, Util::CountOf(scBasic.CompletedBy));
|
|
|
|
highscore->company_value = scBasic.CompanyValue;
|
2016-10-12 13:36:30 +02:00
|
|
|
highscore->timestamp = DATETIME64_MIN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-11-30 23:32:47 +01:00
|
|
|
catch (const Exception &)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
2016-12-14 00:33:16 +01:00
|
|
|
Console::Error::WriteLine("Error reading legacy scenario scores file: '%s'", path.c_str());
|
2016-10-12 13:36:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (highscoresDirty)
|
|
|
|
{
|
|
|
|
SaveHighscores();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ClearHighscores()
|
|
|
|
{
|
|
|
|
for (auto highscore : _highscores)
|
|
|
|
{
|
|
|
|
scenario_highscore_free(highscore);
|
|
|
|
}
|
|
|
|
_highscores.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
scenario_highscore_entry * InsertHighscore()
|
|
|
|
{
|
|
|
|
auto highscore = new scenario_highscore_entry();
|
|
|
|
memset(highscore, 0, sizeof(scenario_highscore_entry));
|
|
|
|
_highscores.push_back(highscore);
|
|
|
|
return highscore;
|
|
|
|
}
|
|
|
|
|
|
|
|
void AttachHighscores()
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < _highscores.size(); i++)
|
|
|
|
{
|
|
|
|
scenario_highscore_entry * highscore = _highscores[i];
|
2016-10-14 01:01:34 +02:00
|
|
|
scenario_index_entry * scenerio = GetByFilename(highscore->fileName);
|
2016-10-12 13:36:30 +02:00
|
|
|
if (scenerio != nullptr)
|
|
|
|
{
|
|
|
|
scenerio->highscore = highscore;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SaveHighscores()
|
|
|
|
{
|
2016-12-10 20:20:32 +01:00
|
|
|
std::string path = _env->GetFilePath(PATHID::SCORES);
|
2016-10-12 13:36:30 +02:00
|
|
|
try
|
|
|
|
{
|
2016-12-10 20:20:32 +01:00
|
|
|
auto fs = FileStream(path, FILE_MODE_WRITE);
|
2016-10-12 13:36:30 +02:00
|
|
|
fs.WriteValue<uint32>(HighscoreFileVersion);
|
|
|
|
fs.WriteValue<uint32>((uint32)_highscores.size());
|
|
|
|
for (size_t i = 0; i < _highscores.size(); i++)
|
|
|
|
{
|
|
|
|
const scenario_highscore_entry * highscore = _highscores[i];
|
|
|
|
fs.WriteString(highscore->fileName);
|
|
|
|
fs.WriteString(highscore->name);
|
|
|
|
fs.WriteValue(highscore->company_value);
|
|
|
|
fs.WriteValue(highscore->timestamp);
|
|
|
|
}
|
|
|
|
}
|
2016-11-30 23:32:47 +01:00
|
|
|
catch (const Exception &)
|
2016-10-12 13:36:30 +02:00
|
|
|
{
|
2016-12-14 00:33:16 +01:00
|
|
|
Console::Error::WriteLine("Unable to save highscores to '%s'", path.c_str());
|
2016-10-12 13:36:30 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-07-20 18:44:31 +02:00
|
|
|
static ScenarioRepository * _scenarioRepository;
|
2016-10-12 13:36:30 +02:00
|
|
|
|
2016-12-10 20:20:32 +01:00
|
|
|
IScenarioRepository * CreateScenarioRepository(IPlatformEnvironment * env)
|
|
|
|
{
|
2017-07-20 18:44:31 +02:00
|
|
|
_scenarioRepository = new ScenarioRepository(env);
|
|
|
|
return _scenarioRepository;
|
2016-12-10 20:20:32 +01:00
|
|
|
}
|
|
|
|
|
2016-10-12 13:36:30 +02:00
|
|
|
IScenarioRepository * GetScenarioRepository()
|
|
|
|
{
|
2017-07-20 18:44:31 +02:00
|
|
|
return _scenarioRepository;
|
2016-10-12 13:36:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C"
|
|
|
|
{
|
|
|
|
void scenario_repository_scan()
|
|
|
|
{
|
|
|
|
IScenarioRepository * repo = GetScenarioRepository();
|
|
|
|
repo->Scan();
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t scenario_repository_get_count()
|
|
|
|
{
|
|
|
|
IScenarioRepository * repo = GetScenarioRepository();
|
|
|
|
return repo->GetCount();
|
|
|
|
}
|
|
|
|
|
|
|
|
const scenario_index_entry *scenario_repository_get_by_index(size_t index)
|
|
|
|
{
|
|
|
|
IScenarioRepository * repo = GetScenarioRepository();
|
|
|
|
return repo->GetByIndex(index);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool scenario_repository_try_record_highscore(const utf8 * scenarioFileName, money32 companyValue, const utf8 * name)
|
|
|
|
{
|
|
|
|
IScenarioRepository * repo = GetScenarioRepository();
|
|
|
|
return repo->TryRecordHighscore(scenarioFileName, companyValue, name);
|
|
|
|
}
|
|
|
|
}
|