/* We store the offset of each member of the #LinkGraphSettings in the

	 * extra data of the saveload struct. Use it together with the address

	 * of the settings struct inside the job to find the final memory address. */

	static SaveLoadAddrProc * const proc = [](void *b, size_t extra) -> void * { return const_cast<void *>(static_cast<const void *>(reinterpret_cast<const char *>(std::addressof(static_cast<LinkGraphJob *>(b)->settings)) + extra)); };

	/* Build the SaveLoad array on first call and don't touch it later on */

	if (saveloads.size() == 0) {

		size_t prefixlen = strlen(prefix);

		int setting = 0;

		const SettingDesc *desc = GetSettingDescription(setting);

		while (desc->save.cmd != SL_END) {

				SaveLoad sl = desc->save;

				sl.address_proc = proc;

				saveloads.push_back(sl);

			}

			desc = GetSettingDescription(++setting);

		}

		int i = 0;

		do {

			saveloads.push_back(job_desc[i++]);

		} while (saveloads[saveloads.size() - 1].cmd != SL_END);

	}

#include "../../stdafx.h"

#include "script_gamesettings.hpp"

#include "../../settings_internal.h"

#include "../../settings_type.h"

#include "../../command_type.h"

#include "../../safeguards.h"

/* static */ bool ScriptGameSettings::IsValid(const char *setting)

{

	const SettingDesc *sd = GetSettingFromName(setting);

}

/* static */ int32 ScriptGameSettings::GetValue(const char *setting)

{

	if (!IsValid(setting)) return -1;

	const SettingDesc *sd = GetSettingFromName(setting);

	void *ptr = GetVariableAddress(&_settings_game, &sd->save);

	return (int32)ReadValue(ptr, sd->save.conv);

}

/* static */ bool ScriptGameSettings::SetValue(const char *setting, int value)

{

	if (!IsValid(setting)) return false;

	const SettingDesc *sd = GetSettingFromName(setting);

	if ((sd->save.conv & SLF_NO_NETWORK_SYNC) != 0) return false;

	return ScriptObject::DoCommand(0, GetSettingIndex(sd), value, CMD_CHANGE_SETTING);

}

/* static */ bool ScriptGameSettings::IsDisabledVehicleType(ScriptVehicle::VehicleType vehicle_type)

{

	switch (vehicle_type) {

		case ScriptVehicle::VT_RAIL:  return _settings_game.ai.ai_disable_veh_train;

		case ScriptVehicle::VT_ROAD:  return _settings_game.ai.ai_disable_veh_roadveh;

		case ScriptVehicle::VT_WATER: return _settings_game.ai.ai_disable_veh_ship;

		case ScriptVehicle::VT_AIR:   return _settings_game.ai.ai_disable_veh_aircraft;

		default:                       return true;

/**

 * Set the value of a setting and if needed clamp the value to

 * the preset minimum and maximum.

 * @param ptr the variable itself

 * @param sd pointer to the 'information'-database of the variable

 * @param val signed long version of the new value

 * @pre SettingDesc is of type SDT_BOOLX, SDT_NUMX,

 * SDT_ONEOFMANY or SDT_MANYOFMANY. Other types are not supported as of now

 */

static void Write_ValidateSetting(void *ptr, const SettingDesc *sd, int32 val)

{

	if (sdb->cmd != SDT_BOOLX &&

			sdb->cmd != SDT_NUMX &&

			sdb->cmd != SDT_ONEOFMANY &&

			sdb->cmd != SDT_MANYOFMANY) {

		return;

	}

	/* We cannot know the maximum value of a bitset variable, so just have faith */

	if (sdb->cmd != SDT_MANYOFMANY) {

		/* We need to take special care of the uint32 type as we receive from the function

		 * a signed integer. While here also bail out on 64-bit settings as those are not

 * @param ptr Pointer to the std::string.

 * @param sd  Pointer to the information for the conversions and limitations to apply.

 * @param p   The string to save.

 */

static void Write_ValidateStdString(void *ptr, const SettingDesc *sd, const char *p)

{

	std::string *dst = reinterpret_cast<std::string *>(ptr);

	switch (GetVarMemType(sd->save.conv)) {

		case SLE_VAR_STR:

		case SLE_VAR_STRQ:

			if (p != nullptr) {

					/* In case a maximum length is imposed by the setting, the length

					 * includes the '\0' termination for network transfer purposes.

					 * Also ensure the string is valid after chopping of some bytes. */

					dst->assign(str_validate(str, SVS_NONE));

				} else {

					dst->assign(p);

				}

			} else {

				dst->clear();

			}

			break;

		default: NOT_REACHED();

	}

}

 * @param sd pointer to SettingDesc structure whose internally pointed variables will

 *        be given values

 * @param grpname the group of the IniFile to search in for the new values

 * @param object pointer to the object been loaded

 * @param only_startup load only the startup settings set

 */

static void IniLoadSettings(IniFile *ini, const SettingDesc *sd, const char *grpname, void *object, bool only_startup)

{

	IniGroup *group;

	IniGroup *group_def = ini->GetGroup(grpname);

	for (; sd->save.cmd != SL_END; sd++) {

		const SaveLoad        *sld = &sd->save;

		if (!SlIsObjectCurrentlyValid(sld->version_from, sld->version_to)) continue;

		/* For settings.xx.yy load the settings from [xx] yy = ? */

		std::string s{ sdb->name };

		auto sc = s.find('.');

		if (sc != std::string::npos) {

			group = ini->GetGroup(s.substr(0, sc));

			s = s.substr(sc + 1);

		} else {

			group = group_def;

		}

		IniItem *item = group->GetItem(s, false);

			case SDT_STDSTRING:

				Write_ValidateStdString(ptr, sd, (const char *)p);

				break;

			case SDT_INTLIST: {

				if (!LoadIntList((const char*)p, ptr, sld->length, GetVarMemType(sld->conv))) {

					ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_ARRAY);

					msg.SetDParamStr(0, sdb->name);

					_settings_error_list.push_back(msg);

					/* Use default */

					LoadIntList((const char*)sdb->def, ptr, sld->length, GetVarMemType(sld->conv));

				}

				break;

			}

			default: NOT_REACHED();

		}

	}

}

/**

 * Save the values of settings to the inifile.

 * @param ini pointer to IniFile structure

 * @param sd read-only SettingDesc structure which contains the unmodified,

 * have a look if the value has changed since we started the game (the original

 * values are reloaded when saving). If settings indeed have changed, we get

 * these and save them.

 */

static void IniSaveSettings(IniFile *ini, const SettingDesc *sd, const char *grpname, void *object, bool)

{

	IniGroup *group_def = nullptr, *group;

	IniItem *item;

	char buf[512];

	void *ptr;

	for (; sd->save.cmd != SL_END; sd++) {

		const SaveLoad        *sld = &sd->save;

		/* If the setting is not saved to the configuration

		 * file, just continue with the next setting */

		if (!SlIsObjectCurrentlyValid(sld->version_from, sld->version_to)) continue;

		if (sld->conv & SLF_NOT_IN_CONFIG) continue;

		/* XXX - wtf is this?? (group override?) */

		std::string s{ sdb->name };

		auto sc = s.find('.');

		if (sc != std::string::npos) {

			group = ini->GetGroup(s.substr(0, sc));

void IniSaveWindowSettings(IniFile *ini, const char *grpname, void *desc)

{

	IniSaveSettings(ini, _window_settings, grpname, desc, false);

}

/**

 * Check whether the setting is editable in the current gamemode.

 * @param do_command true if this is about checking a command from the server.

 * @return true if editable.

 */

bool SettingDesc::IsEditable(bool do_command) const

{

			(_game_mode == GM_NORMAL ||

	return true;

}

/**

 * Return the type of the setting.

 * @return type of setting

 */

SettingType SettingDesc::GetType() const

{

	return (this->save.conv & SLF_NOT_IN_SAVE) ? ST_CLIENT : ST_GAME;

}

/* Begin - Callback Functions for the various settings. */

/** Reposition the main toolbar as the setting changed. */

static bool v_PositionMainToolbar(int32 p1)

{

	if (_game_mode != GM_MENU) PositionMainToolbar(nullptr);

	return true;

}

	if (flags & DC_EXEC) {

		void *var = GetVariableAddress(&GetGameSettings(), &sd->save);

		int32 oldval = (int32)ReadValue(var, sd->save.conv);

		int32 newval = (int32)p2;

		Write_ValidateSetting(var, sd, newval);

		newval = (int32)ReadValue(var, sd->save.conv);

		if (oldval == newval) return CommandCost();

			WriteValue(var, sd->save.conv, (int64)oldval);

			return CommandCost();

		}

			GamelogStartAction(GLAT_SETTING);

			GamelogStopAction();

		}

		SetWindowClassesDirty(WC_GAME_OPTIONS);

		if (_save_config) SaveToConfig();

	}

	return CommandCost();

}

/**

	if (flags & DC_EXEC) {

		void *var = GetVariableAddress(&Company::Get(_current_company)->settings, &sd->save);

		int32 oldval = (int32)ReadValue(var, sd->save.conv);

		int32 newval = (int32)p2;

		Write_ValidateSetting(var, sd, newval);

		newval = (int32)ReadValue(var, sd->save.conv);

		if (oldval == newval) return CommandCost();

			WriteValue(var, sd->save.conv, (int64)oldval);

			return CommandCost();

		}

		SetWindowClassesDirty(WC_GAME_OPTIONS);

	}

	return CommandCost();

}

/**

 * Get the index of the setting with this description.

 * @param sd the setting to get the index for.

 * @return the index of the setting to be used for CMD_CHANGE_SETTING.

 */

uint GetSettingIndex(const SettingDesc *sd)

{

	return sd - _settings;

}

/**

 * Top function to save the new value of an element of the Settings struct

 * @param index offset in the SettingDesc array of the Settings struct which

 * identifies the setting member we want to change

 * @param value new value of the setting

 * @param force_newgame force the newgame settings

 */

bool SetSettingValue(const SettingDesc *sd, int32 value, bool force_newgame)

{

		if (Company::IsValidID(_local_company) && _game_mode != GM_MENU) {

			return DoCommandP(0, sd - _company_settings, value, CMD_CHANGE_COMPANY_SETTING);

		}

		void *var = GetVariableAddress(&_settings_client.company, &sd->save);

		Write_ValidateSetting(var, sd, value);

		return true;

	}

	/* If an item is company-based, we do not send it over the network

	 * (if any) to change. Also *hack*hack* we update the _newgame version

	 * of settings because changing a company-based setting in a game also

	 * changes its defaults. At least that is the convention we have chosen */

	if (sd->save.conv & SLF_NO_NETWORK_SYNC) {

		void *var = GetVariableAddress(&GetGameSettings(), &sd->save);

		Write_ValidateSetting(var, sd, value);

		if (_game_mode != GM_MENU) {

			void *var2 = GetVariableAddress(&_settings_newgame, &sd->save);

			Write_ValidateSetting(var2, sd, value);

		}

		SetWindowClassesDirty(WC_GAME_OPTIONS);

		if (_save_config) SaveToConfig();

		return true;

	}

	if (force_newgame) {

		void *var2 = GetVariableAddress(&_settings_newgame, &sd->save);

		Write_ValidateSetting(var2, sd, value);

		if (_save_config) SaveToConfig();

	return false;

}

/**

 * Set the company settings for a new company to their default values.

 */

void SetDefaultCompanySettings(CompanyID cid)

{

	Company *c = Company::Get(cid);

	const SettingDesc *sd;

	for (sd = _company_settings; sd->save.cmd != SL_END; sd++) {

		void *var = GetVariableAddress(&c->settings, &sd->save);

	}

}

/**

 * Sync all company settings in a multiplayer game.

 */

void SyncCompanySettings()

{

	const SettingDesc *sd;

	uint i = 0;

	for (sd = _company_settings; sd->save.cmd != SL_END; sd++, i++) {

		const void *old_var = GetVariableAddress(&Company::Get(_current_company)->settings, &sd->save);

		if (old_value != new_value) NetworkSendCommand(0, i, new_value, CMD_CHANGE_COMPANY_SETTING, nullptr, nullptr, _local_company);

	}

}

/**

 * Get the index in the _company_settings array of a setting

 * @param name The name of the setting

 * @return The index in the _company_settings array

 */

uint GetCompanySettingIndex(const char *name)

{

	const SettingDesc *sd = GetSettingFromName(name);

	return sd - _company_settings;

}

/**

 * Set a setting value with a string.

 * @param sd the setting to change.

 * @param value the value to write

 * @param force_newgame force the newgame settings

 * @note Strings WILL NOT be synced over the network

 */

bool SetSettingValue(const SettingDesc *sd, const char *value, bool force_newgame)

{

	assert(sd->save.conv & SLF_NO_NETWORK_SYNC);

	if (GetVarMemType(sd->save.conv) == SLE_VAR_STRQ && strcmp(value, "(null)") == 0) {

		value = nullptr;

	}

	void *ptr = GetVariableAddress((_game_mode == GM_MENU || force_newgame) ? &_settings_newgame : &_settings_game, &sd->save);

	Write_ValidateStdString(ptr, sd, value);

	if (_save_config) SaveToConfig();

	return true;

}

/**

 * Given a name of setting, return a setting description of it.

 * @param name  Name of the setting to return a setting description of

 * @param i     Pointer to an integer that will contain the index of the setting after the call, if it is successful.

 * @return Pointer to the setting description of setting \a name if it can be found,

 *         \c nullptr indicates failure to obtain the description

 */

const SettingDesc *GetSettingFromName(const char *name)

{

	/* First check all full names */

	for (const SettingDesc *sd = _settings; sd->save.cmd != SL_END; sd++) {

		if (!SlIsObjectCurrentlyValid(sd->save.version_from, sd->save.version_to)) continue;

	}

	/* Then check the shortcut variant of the name. */

	for (const SettingDesc *sd = _settings; sd->save.cmd != SL_END; sd++) {

		if (!SlIsObjectCurrentlyValid(sd->save.version_from, sd->save.version_to)) continue;

		if (short_name != nullptr) {

			short_name++;

			if (strcmp(short_name, name) == 0) return sd;

		}

	}

	if (strncmp(name, "company.", 8) == 0) name += 8;

	/* And finally the company-based settings */

	for (const SettingDesc *sd = _company_settings; sd->save.cmd != SL_END; sd++) {

		if (!SlIsObjectCurrentlyValid(sd->save.version_from, sd->save.version_to)) continue;

	}

	return nullptr;

}

/* Those 2 functions need to be here, else we have to make some stuff non-static

 * and besides, it is also better to keep stuff like this at the same place */

void IConsoleSetSetting(const char *name, const char *value, bool force_newgame)

{

	const SettingDesc *sd = GetSettingFromName(name);

	if (sd == nullptr) {

		IConsolePrintF(CC_WARNING, "'%s' is an unknown setting.", name);

		return;

	}

	bool success;

		success = SetSettingValue(sd, value, force_newgame);

	} else {

		uint32 val;

		extern bool GetArgumentInteger(uint32 *value, const char *arg);

		success = GetArgumentInteger(&val, value);

		if (!success) {

			IConsolePrintF(CC_ERROR, "'%s' is not an integer.", value);

			return;

		}

		success = SetSettingValue(sd, val, force_newgame);

	}

{

	char value[20];

	const SettingDesc *sd = GetSettingFromName(name);

	const void *ptr;

	if (sd == nullptr) {

		IConsolePrintF(CC_WARNING, "'%s' is an unknown setting.", name);

		return;

	}

	ptr = GetVariableAddress((_game_mode == GM_MENU || force_newgame) ? &_settings_newgame : &_settings_game, &sd->save);

		IConsolePrintF(CC_WARNING, "Current value for '%s' is: '%s'", name, reinterpret_cast<const std::string *>(ptr)->c_str());

	} else {

			seprintf(value, lastof(value), (*(const bool*)ptr != 0) ? "on" : "off");

		} else {

		}

		IConsolePrintF(CC_WARNING, "Current value for '%s' is: '%s' (min: %s%d, max: %u)",

	}

}

/**

 * List all settings and their value to the console

 *

 * @param prefilter  If not \c nullptr, only list settings with names that begin with \a prefilter prefix

 */

void IConsoleListSettings(const char *prefilter)

{

	IConsolePrintF(CC_WARNING, "All settings with their current value:");

	for (const SettingDesc *sd = _settings; sd->save.cmd != SL_END; sd++) {

		if (!SlIsObjectCurrentlyValid(sd->save.version_from, sd->save.version_to)) continue;

		char value[80];

		const void *ptr = GetVariableAddress(&GetGameSettings(), &sd->save);

			seprintf(value, lastof(value), (*(const bool *)ptr != 0) ? "on" : "off");

			seprintf(value, lastof(value), "%s", reinterpret_cast<const std::string *>(ptr)->c_str());

		} else {

		}

	}

	IConsolePrintF(CC_WARNING, "Use 'setting' command to change a value");

}

/**

 * Save and load handler for settings

 * @param osd SettingDesc struct containing all information

 * @param object can be either nullptr in which case we load global variables or

 * a pointer to a struct which is getting saved

 */

static void LoadSettings(const SettingDesc *osd, void *object)

	virtual uint Length() const;

	virtual uint GetMaxHelpHeight(int maxw);

	virtual bool UpdateFilterState(SettingFilter &filter, bool force_visible);

	void SetButtons(byte new_val);

	/**

	 * Get the help text of a single setting.

	 * @return The requested help text.

	 */

	inline StringID GetHelpText() const

	{

	}

	void SetValueDParams(uint first_param, int32 value) const;

protected:

	virtual void DrawSetting(GameSettings *settings_ptr, int left, int right, int y, bool highlight) const;

private:

	bool IsVisibleByRestrictionMode(RestrictionMode mode) const;

};

/** Containers for BaseSettingEntry */

 * @param level      Page nesting level of this entry

 */

void SettingEntry::Init(byte level)

{

	BaseSettingEntry::Init(level);

	this->setting = GetSettingFromName(this->name);

	assert(this->setting != nullptr);

}

/* Sets the given setting entry to its default value */

void SettingEntry::ResetAll()

{

	SetSettingValue(this->setting, default_value);

}

/**

 * Set the button-depressed flags (#SEF_LEFT_DEPRESSED and #SEF_RIGHT_DEPRESSED) to a specified value

 * @param new_val New value for the button flags

 * @see SettingEntryFlags

 */

void SettingEntry::SetButtons(byte new_val)

{

	assert((new_val & ~SEF_BUTTONS_MASK) == 0); // Should not touch any flags outside the buttons

	this->flags = (this->flags & ~SEF_BUTTONS_MASK) | new_val;

 * Checks whether an entry shall be made visible based on the restriction mode.

 * @param mode The current status of the restriction drop down box.

 * @return true if the entry shall be visible.

 */

bool SettingEntry::IsVisibleByRestrictionMode(RestrictionMode mode) const

{

	/* There shall not be any restriction, i.e. all settings shall be visible. */

	if (mode == RM_ALL) return true;

	GameSettings *settings_ptr = &GetGameSettings();

	const SettingDesc *sd = this->setting;

	/* Read the current value. */

	const void *var = ResolveVariableAddress(settings_ptr, sd);

	int64 current_value = ReadValue(var, sd->save.conv);

	int64 filter_value;

	if (mode == RM_CHANGED_AGAINST_DEFAULT) {

		/* This entry shall only be visible, if the value deviates from its default value. */

		/* Read the default value. */

	} else {

		assert(mode == RM_CHANGED_AGAINST_NEW);

		/* This entry shall only be visible, if the value deviates from

		 * its value is used when starting a new game. */

		/* Make sure we're not comparing the new game settings against itself. */

		assert(settings_ptr != &_settings_newgame);

		/* Read the new game's value. */

		var = ResolveVariableAddress(&_settings_newgame, sd);

		filter_value = ReadValue(var, sd->save.conv);

	}

 */

bool SettingEntry::UpdateFilterState(SettingFilter &filter, bool force_visible)

{

	CLRBITS(this->flags, SEF_FILTERED);

	bool visible = true;

	const SettingDesc *sd = this->setting;

	if (!force_visible && !filter.string.IsEmpty()) {

		/* Process the search text filter for this item. */

		filter.string.ResetState();

		SetDParam(0, STR_EMPTY);

		filter.string.AddLine(sdb->str);

		filter.string.AddLine(this->GetHelpText());

		visible = filter.string.GetState();

	}

	if (visible) {

		if (filter.type != ST_ALL && sd->GetType() != filter.type) {

			filter.type_hides = true;

			visible = false;

		if (!this->IsVisibleByRestrictionMode(filter.mode)) {

			while (filter.min_cat < RM_ALL && (filter.min_cat == filter.mode || !this->IsVisibleByRestrictionMode(filter.min_cat))) filter.min_cat++;

			visible = false;

		}

	}

	if (!visible) SETBITS(this->flags, SEF_FILTERED);

	return visible;

}

static const void *ResolveVariableAddress(const GameSettings *settings_ptr, const SettingDesc *sd)

{

		if (Company::IsValidID(_local_company) && _game_mode != GM_MENU) {

			return GetVariableAddress(&Company::Get(_local_company)->settings, &sd->save);

		} else {

			return GetVariableAddress(&_settings_client.company, &sd->save);

		}

	} else {

		return GetVariableAddress(settings_ptr, &sd->save);

	}

}

/**

 * Set the DParams for drawing the value of a setting.

 * @param first_param First DParam to use

 * @param value Setting value to set params for.

 */

void SettingEntry::SetValueDParams(uint first_param, int32 value) const

{

	if (sdb->cmd == SDT_BOOLX) {

		SetDParam(first_param++, value != 0 ? STR_CONFIG_SETTING_ON : STR_CONFIG_SETTING_OFF);

	} else {

		if ((sdb->flags & SGF_MULTISTRING) != 0) {

			SetDParam(first_param++, sdb->str_val - sdb->min + value);

		} else if ((sdb->flags & SGF_DISPLAY_ABS) != 0) {

			SetDParam(first_param++, sdb->str_val + ((value >= 0) ? 1 : 0));

			value = abs(value);

		} else {

			SetDParam(first_param++, sdb->str_val + ((value == 0 && (sdb->flags & SGF_0ISDISABLED) != 0) ? 1 : 0));

		}

		SetDParam(first_param++, value);

/**

 * Function to draw setting value (button + text + current value)

 * @param settings_ptr Pointer to current values of all settings