1

/* $Id$ */

     2

     3

/** @file settings.cpp

     4

 * All actions handling saving and loading of the settings/configuration goes on in this file.

     5

 * The file consists of four parts:

     6

 * <ol>

     7

 * <li>Parsing the configuration file (openttd.cfg). This is achieved with the ini_ functions which

     8

 *     handle various types, such as normal 'key = value' pairs, lists and value combinations of

     9

 *     lists, strings, integers, 'bit'-masks and element selections.

    10

 * <li>Defining the data structures that go into the configuration. These include for example

    11

 *     the _patches struct, but also network-settings, banlists, newgrf, etc. There are a lot

    12

 *     of helper macros available for the various types, and also saving/loading of these settings

    13

 *     in a savegame is handled inside these structures.

    14

 * <li>Handle reading and writing to the setting-structures from inside the game either from

    15

 *     the console for example or through the gui with CMD_ functions.

    16

 * <li>Handle saving/loading of the PATS chunk inside the savegame.

    17

 * </ol>

    18

 * @see SettingDesc

    19

 * @see SaveLoad

    20

 */

    21

    22

#include "stdafx.h"

    23

#include "openttd.h"

    24

#include "currency.h"

    25

#include "screenshot.h"

    26

#include "variables.h"

    27

#include "network/network.h"

    28

#include "network/network_func.h"

    29

#include "settings_internal.h"

    30

#include "command_func.h"

    31

#include "console_func.h"

    32

#include "saveload.h"

    33

#include "npf.h"

    34

#include "yapf/yapf.h"

    35

#include "newgrf.h"

    36

#include "newgrf_config.h"

    37

#include "genworld.h"

    38

#include "rail.h"

    39

#include "train.h"

    40

#include "news_func.h"

    41

#include "window_func.h"

    42

#include "strings_func.h"

    43

#include "vehicle_func.h"

    44

#include "sound_func.h"

    45

#include "core/alloc_func.hpp"

    46

#include "company_func.h"

    47

#include "rev.h"

    48

#ifdef WITH_FREETYPE

    49

#include "fontcache.h"

    50

#endif

    51

#include "spritecache.h"

    52

#include "transparency.h"

    53

#include "textbuf_gui.h"

    54

#include "string_func.h"

    55

#include "rail_gui.h"

    56

#include "elrail_func.h"

    57

#include "gui.h"

    58

#include "town.h"

    59

#include "video/video_driver.hpp"

    60

#include "sound/sound_driver.hpp"

    61

#include "music/music_driver.hpp"

    62

#include "blitter/factory.hpp"

    63

#include "gfxinit.h"

    64

#include "gamelog.h"

    65

#include "station_func.h"

    66

#include "settings_func.h"

    67

#include "ini_type.h"

    68

    69

#include "table/strings.h"

    70

    71

ClientSettings _settings_client;

    72

GameSettings _settings_game;

    73

GameSettings _settings_newgame;

    74

    75

typedef const char *SettingListCallbackProc(const IniItem *item, uint index);

    76

typedef void SettingDescProc(IniFile *ini, const SettingDesc *desc, const char *grpname, void *object);

    77

typedef void SettingDescProcList(IniFile *ini, const char *grpname, char **list, uint len, SettingListCallbackProc proc);

    78

    79

static bool IsSignedVarMemType(VarType vt);

    80

    81

/**

    82

 * Groups in openttd.cfg that are actually lists.

    83

 */

    84

static const char *_list_group_names[] = {

    85

	"bans",

    86

	"newgrf",

    87

	"servers",

    88

	NULL

    89

};

    90

    91

/** Find the index value of a ONEofMANY type in a string seperated by |

    92

 * @param many full domain of values the ONEofMANY setting can have

    93

 * @param one the current value of the setting for which a value needs found

    94

 * @param onelen force calculation of the *one parameter

    95

 * @return the integer index of the full-list, or -1 if not found */

    96

static int lookup_oneofmany(const char *many, const char *one, size_t onelen = 0)

    97

{

    98

	const char *s;

    99

	int idx;

   100

   101

	if (onelen == 0) onelen = strlen(one);

   102

   103

	/* check if it's an integer */

   104

	if (*one >= '0' && *one <= '9')

   105

		return strtoul(one, NULL, 0);

   106

   107

	idx = 0;

   108

	for (;;) {

   109

		/* find end of item */

   110

		s = many;

   111

		while (*s != '|' && *s != 0) s++;

   112

		if ((size_t)(s - many) == onelen && !memcmp(one, many, onelen)) return idx;

   113

		if (*s == 0) return -1;

   114

		many = s + 1;

   115

		idx++;

   116

	}

   117

}

   118

   119

/** Find the set-integer value MANYofMANY type in a string

   120

 * @param many full domain of values the MANYofMANY setting can have

   121

 * @param str the current string value of the setting, each individual

   122

 * of seperated by a whitespace,tab or | character

   123

 * @return the 'fully' set integer, or -1 if a set is not found */

   124

static uint32 lookup_manyofmany(const char *many, const char *str)

   125

{

   126

	const char *s;

   127

	int r;

   128

	uint32 res = 0;

   129

   130

	for (;;) {

   131

		/* skip "whitespace" */

   132

		while (*str == ' ' || *str == '\t' || *str == '|') str++;

   133

		if (*str == 0) break;

   134

   135

		s = str;

   136

		while (*s != 0 && *s != ' ' && *s != '\t' && *s != '|') s++;

   137

   138

		r = lookup_oneofmany(many, str, s - str);

   139

		if (r == -1) return (uint32)-1;

   140

   141

		SetBit(res, r); // value found, set it

   142

		if (*s == 0) break;

   143

		str = s + 1;

   144

	}

   145

	return res;

   146

}

   147

   148

/** Parse an integerlist string and set each found value

   149

 * @param p the string to be parsed. Each element in the list is seperated by a

   150

 * comma or a space character

   151

 * @param items pointer to the integerlist-array that will be filled with values

   152

 * @param maxitems the maximum number of elements the integerlist-array has

   153

 * @return returns the number of items found, or -1 on an error */

   154

static int parse_intlist(const char *p, int *items, int maxitems)

   155

{

   156

	int n = 0, v;

   157

	char *end;

   158

   159

	for (;;) {

   160

		v = strtol(p, &end, 0);

   161

		if (p == end || n == maxitems) return -1;

   162

		p = end;

   163

		items[n++] = v;

   164

		if (*p == '\0') break;

   165

		if (*p != ',' && *p != ' ') return -1;

   166

		p++;

   167

	}

   168

   169

	return n;

   170

}

   171

   172

/** Load parsed string-values into an integer-array (intlist)

   173

 * @param str the string that contains the values (and will be parsed)

   174

 * @param array pointer to the integer-arrays that will be filled

   175

 * @param nelems the number of elements the array holds. Maximum is 64 elements

   176

 * @param type the type of elements the array holds (eg INT8, UINT16, etc.)

   177

 * @return return true on success and false on error */

   178

static bool load_intlist(const char *str, void *array, int nelems, VarType type)

   179

{

   180

	int items[64];

   181

	int i, nitems;

   182

   183

	if (str == NULL) {

   184

		memset(items, 0, sizeof(items));

   185

		nitems = nelems;

   186

	} else {

   187

		nitems = parse_intlist(str, items, lengthof(items));

   188

		if (nitems != nelems) return false;

   189

	}

   190

   191

	switch (type) {

   192

	case SLE_VAR_BL:

   193

	case SLE_VAR_I8:

   194

	case SLE_VAR_U8:

   195

		for (i = 0; i != nitems; i++) ((byte*)array)[i] = items[i];

   196

		break;

   197

	case SLE_VAR_I16:

   198

	case SLE_VAR_U16:

   199

		for (i = 0; i != nitems; i++) ((uint16*)array)[i] = items[i];

   200

		break;

   201

	case SLE_VAR_I32:

   202

	case SLE_VAR_U32:

   203

		for (i = 0; i != nitems; i++) ((uint32*)array)[i] = items[i];

   204

		break;

   205

	default: NOT_REACHED();

   206

	}

   207

   208

	return true;

   209

}

   210

   211

/** Convert an integer-array (intlist) to a string representation. Each value

   212

 * is seperated by a comma or a space character

   213

 * @param buf output buffer where the string-representation will be stored

   214

 * @param array pointer to the integer-arrays that is read from

   215

 * @param nelems the number of elements the array holds.

   216

 * @param type the type of elements the array holds (eg INT8, UINT16, etc.) */

   217

static void make_intlist(char *buf, const void *array, int nelems, VarType type)

   218

{

   219

	int i, v = 0;

   220

	const byte *p = (const byte*)array;

   221

   222

	for (i = 0; i != nelems; i++) {

   223

		switch (type) {

   224

		case SLE_VAR_BL:

   225

		case SLE_VAR_I8:  v = *(int8*)p;   p += 1; break;

   226

		case SLE_VAR_U8:  v = *(byte*)p;   p += 1; break;

   227

		case SLE_VAR_I16: v = *(int16*)p;  p += 2; break;

   228

		case SLE_VAR_U16: v = *(uint16*)p; p += 2; break;

   229

		case SLE_VAR_I32: v = *(int32*)p;  p += 4; break;

   230

		case SLE_VAR_U32: v = *(uint32*)p; p += 4; break;

   231

		default: NOT_REACHED();

   232

		}

   233

		buf += sprintf(buf, (i == 0) ? "%d" : ",%d", v);

   234

	}

   235

}

   236

   237

/** Convert a ONEofMANY structure to a string representation.

   238

 * @param buf output buffer where the string-representation will be stored

   239

 * @param many the full-domain string of possible values

   240

 * @param id the value of the variable and whose string-representation must be found */

   241

static void make_oneofmany(char *buf, const char *many, int id)

   242

{

   243

	int orig_id = id;

   244

   245

	/* Look for the id'th element */

   246

	while (--id >= 0) {

   247

		for (; *many != '|'; many++) {

   248

			if (*many == '\0') { // not found

   249

				sprintf(buf, "%d", orig_id);

   250

				return;

   251

			}

   252

		}

   253

		many++; // pass the |-character

   254

	}

   255

   256

	/* copy string until next item (|) or the end of the list if this is the last one */

   257

	while (*many != '\0' && *many != '|') *buf++ = *many++;

   258

	*buf = '\0';

   259

}

   260

   261

/** Convert a MANYofMANY structure to a string representation.

   262

 * @param buf output buffer where the string-representation will be stored

   263

 * @param many the full-domain string of possible values

   264

 * @param x the value of the variable and whose string-representation must

   265

 *        be found in the bitmasked many string */

   266

static void make_manyofmany(char *buf, const char *many, uint32 x)

   267

{

   268

	const char *start;

   269

	int i = 0;

   270

	bool init = true;

   271

   272

	for (; x != 0; x >>= 1, i++) {

   273

		start = many;

   274

		while (*many != 0 && *many != '|') many++; // advance to the next element

   275

   276

		if (HasBit(x, 0)) { // item found, copy it

   277

			if (!init) *buf++ = '|';

   278

			init = false;

   279

			if (start == many) {

   280

				buf += sprintf(buf, "%d", i);

   281

			} else {

   282

				memcpy(buf, start, many - start);

   283

				buf += many - start;

   284

			}

   285

		}

   286

   287

		if (*many == '|') many++;

   288

	}

   289

   290

	*buf = '\0';

   291

}

   292

   293

/** Convert a string representation (external) of a setting to the internal rep.

   294

 * @param desc SettingDesc struct that holds all information about the variable

   295

 * @param str input string that will be parsed based on the type of desc

   296

 * @return return the parsed value of the setting */

   297

static const void *string_to_val(const SettingDescBase *desc, const char *str)

   298

{

   299

	switch (desc->cmd) {

   300

	case SDT_NUMX: {

   301

		char *end;

   302

		unsigned long val = strtoul(str, &end, 0);

   303

		if (*end != '\0') ShowInfoF("ini: trailing characters at end of setting '%s'", desc->name);

   304

		return (void*)val;

   305

	}

   306

	case SDT_ONEOFMANY: {

   307

		long r = lookup_oneofmany(desc->many, str);

   308

		/* if the first attempt of conversion from string to the appropriate value fails,

   309

		 * look if we have defined a converter from old value to new value. */

   310

		if (r == -1 && desc->proc_cnvt != NULL) r = desc->proc_cnvt(str);

   311

		if (r != -1) return (void*)r; //and here goes converted value

   312

		ShowInfoF("ini: invalid value '%s' for '%s'", str, desc->name); //sorry, we failed

   313

		return 0;

   314

	}

   315

	case SDT_MANYOFMANY: {

   316

		unsigned long r = lookup_manyofmany(desc->many, str);

   317

		if (r != (unsigned long)-1) return (void*)r;

   318

		ShowInfoF("ini: invalid value '%s' for '%s'", str, desc->name);

   319

		return 0;

   320

	}

   321

	case SDT_BOOLX:

   322

		if (strcmp(str, "true")  == 0 || strcmp(str, "on")  == 0 || strcmp(str, "1") == 0)

   323

			return (void*)true;

   324

		if (strcmp(str, "false") == 0 || strcmp(str, "off") == 0 || strcmp(str, "0") == 0)

   325

			return (void*)false;

   326

		ShowInfoF("ini: invalid setting value '%s' for '%s'", str, desc->name);

   327

		break;

   328

   329

	case SDT_STRING:

   330

	case SDT_INTLIST: return str;

   331

	default: break;

   332

	}

   333

   334

	return NULL;

   335

}

   336

   337

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

   338

 * the preset minimum and maximum.

   339

 * @param ptr the variable itself

   340

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

   341

 * @param val signed long version of the new value

   342

 * @pre SettingDesc is of type SDT_BOOLX, SDT_NUMX,

   343

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

   344

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

   345

{

   346

	const SettingDescBase *sdb = &sd->desc;

   347

   348

	if (sdb->cmd != SDT_BOOLX &&

   349

			sdb->cmd != SDT_NUMX &&

   350

			sdb->cmd != SDT_ONEOFMANY &&

   351

			sdb->cmd != SDT_MANYOFMANY) {

   352

		return;

   353

	}

   354

   355

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

   356

	if (sdb->cmd != SDT_MANYOFMANY) {

   357

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

   358

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

   359

		 * supported. Unsigned 8 and 16-bit variables are safe since they fit into a signed

   360

		 * 32-bit variable

   361

		 * TODO: Support 64-bit settings/variables */

   362

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

   363

			case SLE_VAR_BL:

   364

			case SLE_VAR_I8:

   365

			case SLE_VAR_U8:

   366

			case SLE_VAR_I16:

   367

			case SLE_VAR_U16:

   368

			case SLE_VAR_I32: {

   369

				/* Override the minimum value. No value below sdb->min, except special value 0 */

   370

				int32 min = ((sdb->flags & SGF_0ISDISABLED) && val <= sdb->min) ? 0 : sdb->min;

   371

				val = Clamp(val, min, sdb->max);

   372

			} break;

   373

			case SLE_VAR_U32: {

   374

				/* Override the minimum value. No value below sdb->min, except special value 0 */

   375

				uint min = ((sdb->flags & SGF_0ISDISABLED) && (uint)val <= (uint)sdb->min) ? 0 : sdb->min;

   376

				WriteValue(ptr, SLE_VAR_U32, (int64)ClampU(val, min, sdb->max));

   377

				return;

   378

			}

   379

			case SLE_VAR_I64:

   380

			case SLE_VAR_U64:

   381

			default: NOT_REACHED(); break;

   382

		}

   383

	}

   384

   385

	WriteValue(ptr, sd->save.conv, (int64)val);

   386

}

   387

   388

/** Load values from a group of an IniFile structure into the internal representation

   389

 * @param ini pointer to IniFile structure that holds administrative information

   390

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

   391

 *        be given values

   392

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

   393

 * @param object pointer to the object been loaded */

   394

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

   395

{

   396

	IniGroup *group;

   397

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

   398

	IniItem *item;

   399

	const void *p;

   400

	void *ptr;

   401

	const char *s;

   402

   403

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

   404

		const SettingDescBase *sdb = &sd->desc;

   405

		const SaveLoad        *sld = &sd->save;

   406

   407

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

   408

   409

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

   410

		s = strchr(sdb->name, '.');

   411

		if (s != NULL) {

   412

			group = ini->GetGroup(sdb->name, s - sdb->name);

   413

			s++;

   414

		} else {

   415

			s = sdb->name;

   416

			group = group_def;

   417

		}

   418

   419

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

   420

		if (item == NULL && group != group_def) {

   421

			/* For patches.xx.yy load the settings from [patches] yy = ? in case the previous

   422

			 * did not exist (e.g. loading old config files with a [patches] section */

   423

			item = group_def->GetItem(s, false);

   424

		}

   425

		if (item == NULL) {

   426

			/* For patches.xx.zz.yy load the settings from [zz] yy = ? in case the previous

   427

			 * did not exist (e.g. loading old config files with a [yapf] section */

   428

			const char *sc = strchr(s, '.');

   429

			if (sc != NULL) item = ini->GetGroup(s, sc - s)->GetItem(sc + 1, false);

   430

		}

   431

   432

		p = (item == NULL) ? sdb->def : string_to_val(sdb, item->value);

   433

		ptr = GetVariableAddress(object, sld);

   434

   435

		switch (sdb->cmd) {

   436

		case SDT_BOOLX: /* All four are various types of (integer) numbers */

   437

		case SDT_NUMX:

   438

		case SDT_ONEOFMANY:

   439

		case SDT_MANYOFMANY:

   440

			Write_ValidateSetting(ptr, sd, (unsigned long)p); break;

   441

   442

		case SDT_STRING:

   443

			switch (GetVarMemType(sld->conv)) {

   444

				case SLE_VAR_STRB:

   445

				case SLE_VAR_STRBQ:

   446

					if (p != NULL) ttd_strlcpy((char*)ptr, (const char*)p, sld->length);

   447

					break;

   448

				case SLE_VAR_STR:

   449

				case SLE_VAR_STRQ:

   450

					if (p != NULL) {

   451

						free(*(char**)ptr);

   452

						*(char**)ptr = strdup((const char*)p);

   453

					}

   454

					break;

   455

				case SLE_VAR_CHAR: *(char*)ptr = *(char*)p; break;

   456

				default: NOT_REACHED(); break;

   457

			}

   458

			break;

   459

   460

		case SDT_INTLIST: {

   461

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

   462

				ShowInfoF("ini: error in array '%s'", sdb->name);

   463

			} else if (sd->desc.proc_cnvt != NULL) {

   464

				sd->desc.proc_cnvt((const char*)p);

   465

			}

   466

			break;

   467

		}

   468

		default: NOT_REACHED(); break;

   469

		}

   470

	}

   471

}

   472

   473

/** Save the values of settings to the inifile.

   474

 * @param ini pointer to IniFile structure

   475

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

   476

 *        loaded values of the configuration file and various information about it

   477

 * @param grpname holds the name of the group (eg. [network]) where these will be saved

   478

 * @param object pointer to the object been saved

   479

 * The function works as follows: for each item in the SettingDesc structure we

   480

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

   481

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

   482

 * these and save them.

   483

 */

   484

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

   485

{

   486

	IniGroup *group_def = NULL, *group;

   487

	IniItem *item;

   488

	char buf[512];

   489

	const char *s;

   490

	void *ptr;

   491