return sprite;

}

std::array<uint8_t, NUM_CARGO> _sorted_cargo_types; ///< Sort order of cargoes by cargo ID.

std::vector<const CargoSpec *> _sorted_cargo_specs;   ///< Cargo specifications sorted alphabetically by name.

/** Sort cargo specifications by their name. */

static bool CargoSpecNameSorter(const CargoSpec * const &a, const CargoSpec * const &b)

{

	std::string a_name = GetString(a->name);

	std::string b_name = GetString(b->name);

#include "economy_type.h"

#include "cargo_type.h"

#include "gfx_type.h"

#include "strings_type.h"

#include "landscape_type.h"

#include "core/bitmath_func.hpp"

/** Globally unique label of a cargo type. */

typedef uint32_t CargoLabel;

/** Town growth effect when delivering cargo. */

enum TownEffect : byte {

CargoID GetDefaultCargoID(LandscapeID l, CargoType ct);

Dimension GetLargestCargoIconSize();

void InitializeSortedCargoSpecs();

extern std::array<uint8_t, NUM_CARGO> _sorted_cargo_types;

extern std::vector<const CargoSpec *> _sorted_cargo_specs;

/**

 * Does cargo \a c have cargo class \a cc?

 * @param c  Cargo type.

 * @param cc Cargo class.

 * @return The type fits in the class.

    pool_func.hpp

    pool_type.hpp

    random_func.cpp

    random_func.hpp

    smallstack_type.hpp

    container_func.hpp

    strong_typedef_type.hpp

)

/** @file endian_buffer.hpp Endian-aware buffer. */

#ifndef ENDIAN_BUFFER_HPP

#define ENDIAN_BUFFER_HPP

#include <string_view>

#include "../core/bitmath_func.hpp"

#include "../core/overflowsafe_type.hpp"

struct StrongTypedefBase;

/**

 * @note This class uses operator overloading (>>, just like streams) for reading

 * as this allows providing custom operator overloads for more complex types

 * like e.g. structs without needing to modify this class.

 */

class EndianBufferReader {

	/** Reference to storage buffer. */

	/** Current read position. */

	size_t read_pos = 0;

public:

	void rewind() { this->read_pos = 0; }

	EndianBufferReader &operator >>(std::string &data) { data = this->ReadStr(); return *this; }

	EndianBufferReader &operator >>(bool &data) { data = this->Read<byte>() != 0; return *this; }

			data = this->Read<T>();

		}

		return *this;

	}

	template <typename Tvalue>

	{

		Tvalue result{};

		EndianBufferReader reader{ buffer };

		reader >> result;

		return result;

	}

		AddDirtyBlock(this->left, mintop, this->left + this->width, maxtop + this->height);

	}

	StringID GetCompanyMessageString() const

	{

		/* Company news with a face have a separate headline, so the normal message is shifted by two params */

		return this->ni->params[1].data;

	}

	StringID GetNewVehicleMessageString(WidgetID widget) const

	{

		assert(this->ni->reftype1 == NR_ENGINE);

#ifndef SAVELOAD_H

#define SAVELOAD_H

#include "saveload_error.hpp"

#include "../fileio_type.h"

#include "../fios.h"

/** SaveLoad versions

 * Previous savegame versions, the trunk revision where they were

 * introduced and the released version that had that particular

 * savegame version.

 * Up to savegame version 18 there is a minor version as well.

};

/** A reference to ChunkHandler. */

using ChunkHandlerRef = std::reference_wrapper<const ChunkHandler>;

/** A table of ChunkHandler entries. */

/** A table of SaveLoad entries. */

/** A table of SaveLoadCompat entries. */

/** Handler for saving/loading an object to/from disk. */

class SaveLoadHandler {

public:

	std::optional<std::vector<SaveLoad>> load_description;

 */

static constexpr const SettingDesc *GetSettingDesc(const SettingVariant &desc)

{

	return std::visit([](auto&& arg) -> const SettingDesc * { return &arg; }, desc);

}

const SettingDesc *GetSettingFromName(const std::string_view name);

void GetSaveLoadFromSettingTable(SettingTable settings, std::vector<SaveLoad> &saveloads);

bool SetSettingValue(const IntSettingDesc *sd, int32_t value, bool force_newgame = false);

bool SetSettingValue(const StringSettingDesc *sd, const std::string value, bool force_newgame = false);

#include <limits>

#include <map>

#include <memory>

#include <numeric>

#include <optional>

#include <set>

#include <stdexcept>

#include <string>

#include <type_traits>

#include <variant>

#include <vector>

/**

 * Format a byte array into a continuous hex string.

 * @param data Array to format

 * @return Converted string.

 */

{

	std::string str;

	str.reserve(data.size() * 2 + 1);

	for (auto b : data) {

		fmt::format_to(std::back_inserter(str), "{:02X}", b);

#ifndef STRING_FUNC_H

#define STRING_FUNC_H

#include <iosfwd>

#include "core/bitmath_func.hpp"

#include "string_type.h"

char *strecpy(char *dst, const char *src, const char *last) NOACCESS(3);

void StrMakeValidInPlace(char *str, const char *last, StringValidationSettings settings = SVS_REPLACE_WITH_QUESTION_MARK) NOACCESS(2);

[[nodiscard]] std::string StrMakeValid(std::string_view str, StringValidationSettings settings = SVS_REPLACE_WITH_QUESTION_MARK);

void StrMakeValidInPlace(char *str, StringValidationSettings settings = SVS_REPLACE_WITH_QUESTION_MARK);

bool strtolower(std::string &str, std::string::size_type offs = 0);

}

/**

 * Copy the parameters from the backup into the global string parameter array.

 * @param backup The backup to copy from.

 */

{

	for (size_t i = 0; i < backup.size(); i++) {

		auto &value = backup[i];

		if (value.string.has_value()) {

			_global_string_params.SetParam(i, value.string.value());

		} else {

#define STRINGS_FUNC_H

#include "strings_type.h"

#include "string_type.h"

#include "gfx_type.h"

#include "core/bitmath_func.hpp"

#include "core/strong_typedef_type.hpp"

#include "vehicle_type.h"

/**

 * Extract the StringTab from a StringID.

 * @param str String identifier

}

void SetDParamStr(size_t n, const char *str);

void SetDParamStr(size_t n, const std::string &str);

void SetDParamStr(size_t n, std::string &&str);

void CopyOutDParam(std::vector<StringParameterBackup> &backup, size_t num);

bool HaveDParamChanged(const std::vector<StringParameterBackup> &backup);

uint64_t GetDParam(size_t n);

extern TextDirection _current_text_dir; ///< Text direction of the currently selected language

#ifndef STRINGS_INTERNAL_H

#define STRINGS_INTERNAL_H

#include "strings_func.h"

#include "string_func.h"

/** The data required to format and validate a single parameter of a string. */

struct StringParameter {

	uint64_t data; ///< The data of the parameter.

	const char *string_view; ///< The string value, if it has any.

	std::unique_ptr<std::string> string; ///< Copied string value, if it has any.

	char32_t type; ///< The #StringControlCode to interpret this data with when it's the first parameter, otherwise '\0'.

};

class StringParameters {

protected:

	StringParameters *parent = nullptr; ///< If not nullptr, this instance references data from this parent instance.

	size_t offset = 0; ///< Current offset in the parameters span.

	char32_t next_type = 0; ///< The type of the next data that is retrieved.

		parameters(parameters)

	{}

	StringParameter *GetNextParameterPointer();

public:

class ArrayStringParameters : public StringParameters {

	std::array<StringParameter, N> params{}; ///< The actual parameters

public:

	ArrayStringParameters()

	{

	}

	ArrayStringParameters(ArrayStringParameters&& other) noexcept

	{

		*this = std::move(other);

	}

	ArrayStringParameters& operator=(ArrayStringParameters &&other) noexcept

	{

		this->offset = other.offset;

		this->next_type = other.next_type;

		this->params = std::move(other.params);

		return *this;

	}

	ArrayStringParameters(const ArrayStringParameters &other) = delete;

	ArrayStringParameters& operator=(const ArrayStringParameters &other) = delete;

};

		survey["video_info"] = VideoDriver::GetInstance()->GetInfoString();

	}

	if (BaseGraphics::GetUsedSet() != nullptr) {

		survey["graphics_set"] = fmt::format("{}.{}", BaseGraphics::GetUsedSet()->name, BaseGraphics::GetUsedSet()->version);

		const GRFConfig *extra_cfg = BaseGraphics::GetUsedSet()->GetExtraConfig();

		if (extra_cfg != nullptr && extra_cfg->num_params > 0) {

		} else {

		}

	}

	if (BaseMusic::GetUsedSet() != nullptr) {

		survey["music_set"] = fmt::format("{}.{}", BaseMusic::GetUsedSet()->name, BaseMusic::GetUsedSet()->version);

	}

	if (BaseSounds::GetUsedSet() != nullptr) {

		if ((c->palette & GRFP_GRF_MASK) == GRFP_GRF_ANY) grf["palette"] = "any";

		if ((c->palette & GRFP_BLT_MASK) == GRFP_BLT_UNSET) grf["blitter"] = "unset";

		if ((c->palette & GRFP_BLT_MASK) == GRFP_BLT_32BPP) grf["blitter"] = "32bpp";

		grf["is_static"] = HasBit(c->flags, GCF_STATIC);

	}

}

/**

 * Convert game-script information to JSON.

 *