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 last last item to write to in the output buffer

   215

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

   216

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

   217

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

   218

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

   219

{

   220

	int i, v = 0;

   221

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

   222

   223

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

   224

		switch (type) {

   225

		case SLE_VAR_BL:

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

		default: NOT_REACHED();

   233

		}

   234

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

   235

	}

   236

}

   237

   238

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

   239

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

   240

 * @param last last item to write to in the output buffer

   241

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

   242

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

   243

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

   244

{

   245

	int orig_id = id;

   246

   247

	/* Look for the id'th element */

   248

	while (--id >= 0) {

   249

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

   250

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

   251

				seprintf(buf, last, "%d", orig_id);

   252

				return;

   253

			}

   254

		}

   255

		many++; // pass the |-character

   256

	}

   257

   258

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

   259

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

   260

	*buf = '\0';

   261

}

   262

   263

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

   264

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

   265

 * @param last last item to write to in the output buffer

   266

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

   267

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

   268

 *        be found in the bitmasked many string */

   269

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

   270

{

   271

	const char *start;

   272

	int i = 0;

   273

	bool init = true;

   274

   275

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

   276

		start = many;

   277

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

   278

   279

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

   280

			if (!init) buf += seprintf(buf, last, "|");

   281

			init = false;

   282

			if (start == many) {

   283

				buf += seprintf(buf, last, "%d", i);

   284

			} else {

   285

				memcpy(buf, start, many - start);

   286

				buf += many - start;

   287

			}

   288

		}

   289

   290

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

   291

	}

   292

   293

	*buf = '\0';

   294

}

   295

   296

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

   297

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

   298

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

   299

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

   300

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

   301

{

   302

	switch (desc->cmd) {

   303

	case SDT_NUMX: {

   304

		char *end;

   305

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

   306

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

   307

		return (void*)val;

   308

	}

   309

	case SDT_ONEOFMANY: {

   310

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

   311

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

   312

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

   313

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

   314

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

   315

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

   316

		return 0;

   317

	}

   318

	case SDT_MANYOFMANY: {

   319

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

   320

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

   321

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

   322

		return 0;

   323

	}

   324

	case SDT_BOOLX:

   325

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

   326

			return (void*)true;

   327

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

   328

			return (void*)false;

   329

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

   330

		break;

   331

   332

	case SDT_STRING:

   333

	case SDT_INTLIST: return str;

   334

	default: break;

   335

	}

   336

   337

	return NULL;

   338

}

   339

   340

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

   341

 * the preset minimum and maximum.

   342

 * @param ptr the variable itself

   343

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

   344

 * @param val signed long version of the new value

   345

 * @pre SettingDesc is of type SDT_BOOLX, SDT_NUMX,

   346

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

   347

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

   348

{

   349

	const SettingDescBase *sdb = &sd->desc;

   350

   351

	if (sdb->cmd != SDT_BOOLX &&

   352

			sdb->cmd != SDT_NUMX &&

   353

			sdb->cmd != SDT_ONEOFMANY &&

   354

			sdb->cmd != SDT_MANYOFMANY) {

   355

		return;

   356

	}

   357

   358

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

   359

	if (sdb->cmd != SDT_MANYOFMANY) {

   360

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

   361

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

   362

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

   363

		 * 32-bit variable

   364

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

   365

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

   366

			case SLE_VAR_BL:

   367

			case SLE_VAR_I8:

   368

			case SLE_VAR_U8:

   369

			case SLE_VAR_I16:

   370

			case SLE_VAR_U16:

   371

			case SLE_VAR_I32: {

   372

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

   373

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

   374

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

   375

			} break;

   376

			case SLE_VAR_U32: {

   377

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

   378

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

   379

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

   380

				return;

   381

			}

   382

			case SLE_VAR_I64:

   383

			case SLE_VAR_U64:

   384

			default: NOT_REACHED(); break;

   385

		}

   386

	}

   387

   388

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

   389

}

   390

   391

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

   392

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

   393

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

   394

 *        be given values

   395

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

   396

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

   397

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

   398

{

   399

	IniGroup *group;

   400

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

   401

	IniItem *item;

   402

	const void *p;

   403

	void *ptr;

   404

	const char *s;

   405

   406

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

   407

		const SettingDescBase *sdb = &sd->desc;

   408

		const SaveLoad        *sld = &sd->save;

   409

   410

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

   411

   412

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

   413

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

   414

		if (s != NULL) {

   415

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

   416

			s++;

   417

		} else {

   418

			s = sdb->name;

   419

			group = group_def;

   420

		}

   421

   422

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

   423

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

   424

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

   425

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

   426

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

   427

		}

   428

		if (item == NULL) {

   429

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

   430

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

   431

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

   432

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

   433

		}

   434

   435

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

   436

		ptr = GetVariableAddress(object, sld);

   437

   438

		switch (sdb->cmd) {

   439

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

   440

		case SDT_NUMX:

   441

		case SDT_ONEOFMANY:

   442

		case SDT_MANYOFMANY:

   443

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

   444

   445

		case SDT_STRING:

   446

			switch (GetVarMemType(sld->conv)) {

   447

				case SLE_VAR_STRB:

   448

				case SLE_VAR_STRBQ:

   449

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

   450

					break;

   451

				case SLE_VAR_STR:

   452

				case SLE_VAR_STRQ:

   453

					if (p != NULL) {

   454

						free(*(char**)ptr);

   455

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

   456

					}

   457

					break;

   458

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

   459

				default: NOT_REACHED(); break;

   460

			}

   461

			break;

   462

   463

		case SDT_INTLIST: {

   464

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

   465

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

   466

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

   467

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

   468

			}

   469

			break;

   470

		}

   471

		default: NOT_REACHED(); break;

   472

		}

   473

	}

   474

}

   475

   476

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

   477

 * @param ini pointer to IniFile structure

   478

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

   479

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

   480

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

   481

 * @param object pointer to the object been saved

   482

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

   483

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

   484

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

   485

 * these and save them.

   486

 */

   487

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

   488

{

   489

	IniGroup *group_def = NULL, *group;

   490

	IniItem *item;