Mercurial Mercurial > openttd-ottdgrfs / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
src/genworld_gui.cpp
branchnoai
changeset 10715 6bdf79ffb022
parent 10645 8cbdb511a674
child 10776 07203fc29812
equal deleted inserted replaced
10713:c5c9dc32c052 10715:6bdf79ffb022 
    46 
    46 
    47 extern void SwitchMode(int new_mode);
 
    47 extern void SwitchMode(int new_mode);
 
    48 
    48 
    49 static inline void SetNewLandscapeType(byte landscape)
 
    49 static inline void SetNewLandscapeType(byte landscape)
 
    50 {
 
    50 {
 
    51 	_opt_newgame.landscape = landscape;
 
    51 	_settings_newgame.game_creation.landscape = landscape;
 
    52 	InvalidateWindowClasses(WC_SELECT_GAME);
 
    52 	InvalidateWindowClasses(WC_SELECT_GAME);
 
    53 	InvalidateWindowClasses(WC_GENERATE_LANDSCAPE);
 
    53 	InvalidateWindowClasses(WC_GENERATE_LANDSCAPE);
 
    54 }
 
    54 }
 
    55 
    55 
    56 enum GenerateLandscapeWindowWidgets {
 
    56 enum GenerateLandscapeWindowWidgets {
 
   204 {
 
   204 {
 
   205 	DeleteAllNonVitalWindows();
 
   205 	DeleteAllNonVitalWindows();
 
   206 
   206 
   207 	/* Copy all XXX_newgame to XXX when coming from outside the editor */
 
   207 	/* Copy all XXX_newgame to XXX when coming from outside the editor */
 
   208 	UpdatePatches();
 
   208 	UpdatePatches();
 
   209 	_opt = _opt_newgame;
 
       
   210 	_opt_ptr = &_opt;
 
       
   211 	ResetGRFConfig(true);
 
   209 	ResetGRFConfig(true);
 
   212 
   210 
   213 	SndPlayFx(SND_15_BEEP);
 
   211 	SndPlayFx(SND_15_BEEP);
 
   214 	switch (mode) {
 
   212 	switch (mode) {
 
   215 		case GLWP_GENERATE:  _switch_mode = (_game_mode == GM_EDITOR) ? SM_GENRANDLAND    : SM_NEWGAME;         break;
 
   213 		case GLWP_GENERATE:  _switch_mode = (_game_mode == GM_EDITOR) ? SM_GENRANDLAND    : SM_NEWGAME;         break;
 
   253 	char name[64];
 
   251 	char name[64];
 
   254 	glwp_modes mode;
 
   252 	glwp_modes mode;
 
   255 
   253 
   256 	GenerateLandscapeWindow(const WindowDesc *desc, WindowNumber number = 0) : QueryStringBaseWindow(desc, number)
 
   254 	GenerateLandscapeWindow(const WindowDesc *desc, WindowNumber number = 0) : QueryStringBaseWindow(desc, number)
 
   257 	{
 
   255 	{
 
   258 		this->LowerWidget(_opt_newgame.landscape + GLAND_TEMPERATE);
 
   256 		this->LowerWidget(_settings_newgame.game_creation.landscape + GLAND_TEMPERATE);
 
   259 
   257 
   260 		snprintf(this->edit_str_buf, sizeof(this->edit_str_buf), "%u", _patches_newgame.generation_seed);
 
   258 		snprintf(this->edit_str_buf, sizeof(this->edit_str_buf), "%u", _settings_newgame.game_creation.generation_seed);
 
   261 		InitializeTextBuffer(&this->text, this->edit_str_buf, lengthof(this->edit_str_buf), 120);
 
   259 		InitializeTextBuffer(&this->text, this->edit_str_buf, lengthof(this->edit_str_buf), 120);
 
   262 		this->caption = STR_NULL;
 
   260 		this->caption = STR_NULL;
 
   263 		this->afilter = CS_NUMERAL;
 
   261 		this->afilter = CS_NUMERAL;
 
   264 
   262 
   265 		this->mode = (glwp_modes)this->window_number;
 
   263 		this->mode = (glwp_modes)this->window_number;
 
   269 
   267 
   270 	virtual void OnPaint()
 
   268 	virtual void OnPaint()
 
   271 	{
 
   269 	{
 
   272 		/* You can't select smoothness if not terragenesis */
 
   270 		/* You can't select smoothness if not terragenesis */
 
   273 		if (mode == GLWP_GENERATE) {
 
   271 		if (mode == GLWP_GENERATE) {
 
   274 			this->SetWidgetDisabledState(GLAND_SMOOTHNESS_PULLDOWN, _patches_newgame.land_generator == 0);
 
   272 			this->SetWidgetDisabledState(GLAND_SMOOTHNESS_PULLDOWN, _settings_newgame.game_creation.land_generator == 0);
 
   275 		}
 
   273 		}
 
   276 		/* Disable snowline if not hilly */
 
   274 		/* Disable snowline if not hilly */
 
   277 		this->SetWidgetDisabledState(GLAND_SNOW_LEVEL_TEXT, _opt_newgame.landscape != LT_ARCTIC);
 
   275 		this->SetWidgetDisabledState(GLAND_SNOW_LEVEL_TEXT, _settings_newgame.game_creation.landscape != LT_ARCTIC);
 
   278 		/* Disable town, industry and trees in SE */
 
   276 		/* Disable town, industry and trees in SE */
 
   279 		this->SetWidgetDisabledState(GLAND_TOWN_PULLDOWN,     _game_mode == GM_EDITOR);
 
   277 		this->SetWidgetDisabledState(GLAND_TOWN_PULLDOWN,     _game_mode == GM_EDITOR);
 
   280 		this->SetWidgetDisabledState(GLAND_INDUSTRY_PULLDOWN, _game_mode == GM_EDITOR);
 
   278 		this->SetWidgetDisabledState(GLAND_INDUSTRY_PULLDOWN, _game_mode == GM_EDITOR);
 
   281 		this->SetWidgetDisabledState(GLAND_TREE_PULLDOWN,     _game_mode == GM_EDITOR);
 
   279 		this->SetWidgetDisabledState(GLAND_TREE_PULLDOWN,     _game_mode == GM_EDITOR);
 
   282 
   280 
   283 		this->SetWidgetDisabledState(GLAND_START_DATE_DOWN, _patches_newgame.starting_year <= MIN_YEAR);
 
   281 		this->SetWidgetDisabledState(GLAND_START_DATE_DOWN, _settings_newgame.game_creation.starting_year <= MIN_YEAR);
 
   284 		this->SetWidgetDisabledState(GLAND_START_DATE_UP,   _patches_newgame.starting_year >= MAX_YEAR);
 
   282 		this->SetWidgetDisabledState(GLAND_START_DATE_UP,   _settings_newgame.game_creation.starting_year >= MAX_YEAR);
 
   285 		this->SetWidgetDisabledState(GLAND_SNOW_LEVEL_DOWN, _patches_newgame.snow_line_height <= 2 || _opt_newgame.landscape != LT_ARCTIC);
 
   283 		this->SetWidgetDisabledState(GLAND_SNOW_LEVEL_DOWN, _settings_newgame.game_creation.snow_line_height <= 2 || _settings_newgame.game_creation.landscape != LT_ARCTIC);
 
   286 		this->SetWidgetDisabledState(GLAND_SNOW_LEVEL_UP,   _patches_newgame.snow_line_height >= MAX_SNOWLINE_HEIGHT || _opt_newgame.landscape != LT_ARCTIC);
 
   284 		this->SetWidgetDisabledState(GLAND_SNOW_LEVEL_UP,   _settings_newgame.game_creation.snow_line_height >= MAX_SNOWLINE_HEIGHT || _settings_newgame.game_creation.landscape != LT_ARCTIC);
 
   287 
   285 
   288 		this->SetWidgetLoweredState(GLAND_TEMPERATE, _opt_newgame.landscape == LT_TEMPERATE);
 
   286 		this->SetWidgetLoweredState(GLAND_TEMPERATE, _settings_newgame.game_creation.landscape == LT_TEMPERATE);
 
   289 		this->SetWidgetLoweredState(GLAND_ARCTIC,    _opt_newgame.landscape == LT_ARCTIC);
 
   287 		this->SetWidgetLoweredState(GLAND_ARCTIC,    _settings_newgame.game_creation.landscape == LT_ARCTIC);
 
   290 		this->SetWidgetLoweredState(GLAND_TROPICAL,  _opt_newgame.landscape == LT_TROPIC);
 
   288 		this->SetWidgetLoweredState(GLAND_TROPICAL,  _settings_newgame.game_creation.landscape == LT_TROPIC);
 
   291 		this->SetWidgetLoweredState(GLAND_TOYLAND,   _opt_newgame.landscape == LT_TOYLAND);
 
   289 		this->SetWidgetLoweredState(GLAND_TOYLAND,   _settings_newgame.game_creation.landscape == LT_TOYLAND);
 
   292 
   290 
   293 		if (_game_mode == GM_EDITOR) {
 
   291 		if (_game_mode == GM_EDITOR) {
 
   294 			this->widget[GLAND_TOWN_PULLDOWN].data     = STR_6836_OFF;
 
   292 			this->widget[GLAND_TOWN_PULLDOWN].data     = STR_6836_OFF;
 
   295 			this->widget[GLAND_INDUSTRY_PULLDOWN].data = STR_6836_OFF;
 
   293 			this->widget[GLAND_INDUSTRY_PULLDOWN].data = STR_6836_OFF;
 
   296 		} else {
 
   294 		} else {
 
   297 			this->widget[GLAND_TOWN_PULLDOWN].data     = _num_towns[_opt_newgame.diff.number_towns];
 
   295 			this->widget[GLAND_TOWN_PULLDOWN].data     = _num_towns[_settings_newgame.difficulty.number_towns];
 
   298 			this->widget[GLAND_INDUSTRY_PULLDOWN].data = _num_inds[_opt_newgame.diff.number_industries];
 
   296 			this->widget[GLAND_INDUSTRY_PULLDOWN].data = _num_inds[_settings_newgame.difficulty.number_industries];
 
   299 		}
 
   297 		}
 
   300 
   298 
   301 		if (mode == GLWP_GENERATE) {
 
   299 		if (mode == GLWP_GENERATE) {
 
   302 			this->widget[GLAND_LANDSCAPE_PULLDOWN].data  = _landscape[_patches_newgame.land_generator];
 
   300 			this->widget[GLAND_LANDSCAPE_PULLDOWN].data  = _landscape[_settings_newgame.game_creation.land_generator];
 
   303 			this->widget[GLAND_TREE_PULLDOWN].data       = _tree_placer[_patches_newgame.tree_placer];
 
   301 			this->widget[GLAND_TREE_PULLDOWN].data       = _tree_placer[_settings_newgame.game_creation.tree_placer];
 
   304 			this->widget[GLAND_TERRAIN_PULLDOWN].data    = _elevations[_opt_newgame.diff.terrain_type];
 
   302 			this->widget[GLAND_TERRAIN_PULLDOWN].data    = _elevations[_settings_newgame.difficulty.terrain_type];
 
   305 			this->widget[GLAND_WATER_PULLDOWN].data      = _sea_lakes[_opt_newgame.diff.quantity_sea_lakes];
 
   303 			this->widget[GLAND_WATER_PULLDOWN].data      = _sea_lakes[_settings_newgame.difficulty.quantity_sea_lakes];
 
   306 			this->widget[GLAND_SMOOTHNESS_PULLDOWN].data = _smoothness[_patches_newgame.tgen_smoothness];
 
   304 			this->widget[GLAND_SMOOTHNESS_PULLDOWN].data = _smoothness[_settings_newgame.game_creation.tgen_smoothness];
 
   307 		} else {
 
   305 		} else {
 
   308 			this->widget[GLAND_TREE_PULLDOWN].data               = _tree_placer[_patches_newgame.tree_placer];
 
   306 			this->widget[GLAND_TREE_PULLDOWN].data               = _tree_placer[_settings_newgame.game_creation.tree_placer];
 
   309 			this->widget[GLAND_HEIGHTMAP_ROTATION_PULLDOWN].data = _rotation[_patches_newgame.heightmap_rotation];
 
   307 			this->widget[GLAND_HEIGHTMAP_ROTATION_PULLDOWN].data = _rotation[_settings_newgame.game_creation.heightmap_rotation];
 
   310 		}
 
   308 		}
 
   311 
   309 
   312 		/* Set parameters for widget text that requires them. */
 
   310 		/* Set parameters for widget text that requires them. */
 
   313 		SetDParam(0, ConvertYMDToDate(_patches_newgame.starting_year, 0, 1)); // GLAND_START_DATE_TEXT
 
   311 		SetDParam(0, ConvertYMDToDate(_settings_newgame.game_creation.starting_year, 0, 1)); // GLAND_START_DATE_TEXT
 
   314 		SetDParam(1, 1 << _patches_newgame.map_x); // GLAND_MAPSIZE_X_PULLDOWN
 
   312 		SetDParam(1, 1 << _settings_newgame.game_creation.map_x); // GLAND_MAPSIZE_X_PULLDOWN
 
   315 		SetDParam(2, 1 << _patches_newgame.map_y); // GLAND_MAPSIZE_Y_PULLDOWN
 
   313 		SetDParam(2, 1 << _settings_newgame.game_creation.map_y); // GLAND_MAPSIZE_Y_PULLDOWN
 
   316 		SetDParam(3, _patches_newgame.snow_line_height); // GLAND_SNOW_LEVEL_TEXT
 
   314 		SetDParam(3, _settings_newgame.game_creation.snow_line_height); // GLAND_SNOW_LEVEL_TEXT
 
   317 
   315 
   318 		this->DrawWidgets();
 
   316 		this->DrawWidgets();
 
   319 
   317 
   320 		this->DrawEditBox(GLAND_RANDOM_EDITBOX);
 
   318 		this->DrawEditBox(GLAND_RANDOM_EDITBOX);
 
   321 
   319 
   322 		if (mode != GLWP_GENERATE) {
 
   320 		if (mode != GLWP_GENERATE) {
 
   323 			char buffer[512];
 
   321 			char buffer[512];
 
   324 
   322 
   325 			if (_patches_newgame.heightmap_rotation == HM_CLOCKWISE) {
 
   323 			if (_settings_newgame.game_creation.heightmap_rotation == HM_CLOCKWISE) {
 
   326 				SetDParam(0, this->y);
 
   324 				SetDParam(0, this->y);
 
   327 				SetDParam(1, this->x);
 
   325 				SetDParam(1, this->x);
 
   328 			} else {
 
   326 			} else {
 
   329 				SetDParam(0, this->x);
 
   327 				SetDParam(0, this->x);
 
   330 				SetDParam(1, this->y);
 
   328 				SetDParam(1, this->y);
 
   345 
   343 
   346 			case GLAND_TEMPERATE:
 
   344 			case GLAND_TEMPERATE:
 
   347 			case GLAND_ARCTIC:
 
   345 			case GLAND_ARCTIC:
 
   348 			case GLAND_TROPICAL:
 
   346 			case GLAND_TROPICAL:
 
   349 			case GLAND_TOYLAND:
 
   347 			case GLAND_TOYLAND:
 
   350 				this->RaiseWidget(_opt_newgame.landscape + GLAND_TEMPERATE);
 
   348 				this->RaiseWidget(_settings_newgame.game_creation.landscape + GLAND_TEMPERATE);
 
   351 				SetNewLandscapeType(widget - GLAND_TEMPERATE);
 
   349 				SetNewLandscapeType(widget - GLAND_TEMPERATE);
 
   352 				break;
 
   350 				break;
 
   353 
   351 
   354 			case GLAND_MAPSIZE_X_PULLDOWN: // Mapsize X
 
   352 			case GLAND_MAPSIZE_X_PULLDOWN: // Mapsize X
 
   355 				ShowDropDownList(this, BuildMapsizeDropDown(), _patches_newgame.map_x, GLAND_MAPSIZE_X_PULLDOWN);
 
   353 				ShowDropDownList(this, BuildMapsizeDropDown(), _settings_newgame.game_creation.map_x, GLAND_MAPSIZE_X_PULLDOWN);
 
   356 				break;
 
   354 				break;
 
   357 
   355 
   358 			case GLAND_MAPSIZE_Y_PULLDOWN: // Mapsize Y
 
   356 			case GLAND_MAPSIZE_Y_PULLDOWN: // Mapsize Y
 
   359 				ShowDropDownList(this, BuildMapsizeDropDown(), _patches_newgame.map_y, GLAND_MAPSIZE_Y_PULLDOWN);
 
   357 				ShowDropDownList(this, BuildMapsizeDropDown(), _settings_newgame.game_creation.map_y, GLAND_MAPSIZE_Y_PULLDOWN);
 
   360 				break;
 
   358 				break;
 
   361 
   359 
   362 			case GLAND_TOWN_PULLDOWN: // Number of towns
 
   360 			case GLAND_TOWN_PULLDOWN: // Number of towns
 
   363 				ShowDropDownMenu(this, _num_towns, _opt_newgame.diff.number_towns, GLAND_TOWN_PULLDOWN, 0, 0);
 
   361 				ShowDropDownMenu(this, _num_towns, _settings_newgame.difficulty.number_towns, GLAND_TOWN_PULLDOWN, 0, 0);
 
   364 				break;
 
   362 				break;
 
   365 
   363 
   366 			case GLAND_INDUSTRY_PULLDOWN: // Number of industries
 
   364 			case GLAND_INDUSTRY_PULLDOWN: // Number of industries
 
   367 				ShowDropDownMenu(this, _num_inds, _opt_newgame.diff.number_industries, GLAND_INDUSTRY_PULLDOWN, 0, 0);
 
   365 				ShowDropDownMenu(this, _num_inds, _settings_newgame.difficulty.number_industries, GLAND_INDUSTRY_PULLDOWN, 0, 0);
 
   368 				break;
 
   366 				break;
 
   369 
   367 
   370 			case GLAND_RANDOM_BUTTON: // Random seed
 
   368 			case GLAND_RANDOM_BUTTON: // Random seed
 
   371 				_patches_newgame.generation_seed = InteractiveRandom();
 
   369 				_settings_newgame.game_creation.generation_seed = InteractiveRandom();
 
   372 				snprintf(this->edit_str_buf, lengthof(this->edit_str_buf), "%u", _patches_newgame.generation_seed);
 
   370 				snprintf(this->edit_str_buf, lengthof(this->edit_str_buf), "%u", _settings_newgame.game_creation.generation_seed);
 
   373 				UpdateTextBufferSize(&this->text);
 
   371 				UpdateTextBufferSize(&this->text);
 
   374 				this->SetDirty();
 
   372 				this->SetDirty();
 
   375 				break;
 
   373 				break;
 
   376 
   374 
   377 			case GLAND_RANDOM_EDITBOX: // edit box for random seed
 
   375 			case GLAND_RANDOM_EDITBOX: // edit box for random seed
 
   379 				break;
 
   377 				break;
 
   380 
   378 
   381 			case GLAND_GENERATE_BUTTON: // Generate
 
   379 			case GLAND_GENERATE_BUTTON: // Generate
 
   382 				UpdatePatches();
 
   380 				UpdatePatches();
 
   383 
   381 
   384 				if (_patches.town_layout == TL_NO_ROADS) {
 
   382 				if (_settings.economy.town_layout == TL_NO_ROADS) {
 
   385 					ShowQuery(
 
   383 					ShowQuery(
 
   386 						STR_TOWN_LAYOUT_WARNING_CAPTION,
 
   384 						STR_TOWN_LAYOUT_WARNING_CAPTION,
 
   387 						STR_TOWN_LAYOUT_WARNING_MESSAGE,
 
   385 						STR_TOWN_LAYOUT_WARNING_MESSAGE,
 
   388 						this,
 
   386 						this,
 
   389 						LandscapeGenerationCallback);
 
   387 						LandscapeGenerationCallback);
 
   390 				} else if (mode == GLWP_HEIGHTMAP &&
 
   388 				} else if (mode == GLWP_HEIGHTMAP &&
 
   391 						(this->x * 2 < (1U << _patches_newgame.map_x) ||
 
   389 						(this->x * 2 < (1U << _settings_newgame.game_creation.map_x) ||
 
   392 						this->x / 2 > (1U << _patches_newgame.map_x) ||
 
   390 						this->x / 2 > (1U << _settings_newgame.game_creation.map_x) ||
 
   393 						this->y * 2 < (1U << _patches_newgame.map_y) ||
 
   391 						this->y * 2 < (1U << _settings_newgame.game_creation.map_y) ||
 
   394 						this->y / 2 > (1U << _patches_newgame.map_y))) {
 
   392 						this->y / 2 > (1U << _settings_newgame.game_creation.map_y))) {
 
   395 					ShowQuery(
 
   393 					ShowQuery(
 
   396 						STR_HEIGHTMAP_SCALE_WARNING_CAPTION,
 
   394 						STR_HEIGHTMAP_SCALE_WARNING_CAPTION,
 
   397 						STR_HEIGHTMAP_SCALE_WARNING_MESSAGE,
 
   395 						STR_HEIGHTMAP_SCALE_WARNING_MESSAGE,
 
   398 						this,
 
   396 						this,
 
   399 						LandscapeGenerationCallback);
 
   397 						LandscapeGenerationCallback);
 
   407 				/* Don't allow too fast scrolling */
 
   405 				/* Don't allow too fast scrolling */
 
   408 				if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
 
   406 				if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
 
   409 					this->HandleButtonClick(widget);
 
   407 					this->HandleButtonClick(widget);
 
   410 					this->SetDirty();
 
   408 					this->SetDirty();
 
   411 
   409 
   412 					_patches_newgame.starting_year = Clamp(_patches_newgame.starting_year + widget - GLAND_START_DATE_TEXT, MIN_YEAR, MAX_YEAR);
 
   410 					_settings_newgame.game_creation.starting_year = Clamp(_settings_newgame.game_creation.starting_year + widget - GLAND_START_DATE_TEXT, MIN_YEAR, MAX_YEAR);
 
   413 				}
 
   411 				}
 
   414 				_left_button_clicked = false;
 
   412 				_left_button_clicked = false;
 
   415 				break;
 
   413 				break;
 
   416 
   414 
   417 			case GLAND_START_DATE_TEXT: // Year text
 
   415 			case GLAND_START_DATE_TEXT: // Year text
 
   418 				this->widget_id = GLAND_START_DATE_TEXT;
 
   416 				this->widget_id = GLAND_START_DATE_TEXT;
 
   419 				SetDParam(0, _patches_newgame.starting_year);
 
   417 				SetDParam(0, _settings_newgame.game_creation.starting_year);
 
   420 				ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_START_DATE_QUERY_CAPT, 8, 100, this, CS_NUMERAL);
 
   418 				ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_START_DATE_QUERY_CAPT, 8, 100, this, CS_NUMERAL);
 
   421 				break;
 
   419 				break;
 
   422 
   420 
   423 			case GLAND_SNOW_LEVEL_DOWN:
 
   421 			case GLAND_SNOW_LEVEL_DOWN:
 
   424 			case GLAND_SNOW_LEVEL_UP: // Snow line buttons
 
   422 			case GLAND_SNOW_LEVEL_UP: // Snow line buttons
 
   425 				/* Don't allow too fast scrolling */
 
   423 				/* Don't allow too fast scrolling */
 
   426 				if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
 
   424 				if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
 
   427 					this->HandleButtonClick(widget);
 
   425 					this->HandleButtonClick(widget);
 
   428 					this->SetDirty();
 
   426 					this->SetDirty();
 
   429 
   427 
   430 					_patches_newgame.snow_line_height = Clamp(_patches_newgame.snow_line_height + widget - GLAND_SNOW_LEVEL_TEXT, 2, MAX_SNOWLINE_HEIGHT);
 
   428 					_settings_newgame.game_creation.snow_line_height = Clamp(_settings_newgame.game_creation.snow_line_height + widget - GLAND_SNOW_LEVEL_TEXT, 2, MAX_SNOWLINE_HEIGHT);
 
   431 				}
 
   429 				}
 
   432 				_left_button_clicked = false;
 
   430 				_left_button_clicked = false;
 
   433 				break;
 
   431 				break;
 
   434 
   432 
   435 			case GLAND_SNOW_LEVEL_TEXT: // Snow line text
 
   433 			case GLAND_SNOW_LEVEL_TEXT: // Snow line text
 
   436 				this->widget_id = GLAND_SNOW_LEVEL_TEXT;
 
   434 				this->widget_id = GLAND_SNOW_LEVEL_TEXT;
 
   437 				SetDParam(0, _patches_newgame.snow_line_height);
 
   435 				SetDParam(0, _settings_newgame.game_creation.snow_line_height);
 
   438 				ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_SNOW_LINE_QUERY_CAPT, 3, 100, this, CS_NUMERAL);
 
   436 				ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_SNOW_LINE_QUERY_CAPT, 3, 100, this, CS_NUMERAL);
 
   439 				break;
 
   437 				break;
 
   440 
   438 
   441 			case GLAND_TREE_PULLDOWN: // Tree placer
 
   439 			case GLAND_TREE_PULLDOWN: // Tree placer
 
   442 				ShowDropDownMenu(this, _tree_placer, _patches_newgame.tree_placer, GLAND_TREE_PULLDOWN, 0, 0);
 
   440 				ShowDropDownMenu(this, _tree_placer, _settings_newgame.game_creation.tree_placer, GLAND_TREE_PULLDOWN, 0, 0);
 
   443 				break;
 
   441 				break;
 
   444 
   442 
   445 			case GLAND_LANDSCAPE_PULLDOWN: // Landscape generator OR Heightmap rotation
 
   443 			case GLAND_LANDSCAPE_PULLDOWN: // Landscape generator OR Heightmap rotation
 
   446 			/* case GLAND_HEIGHTMAP_ROTATION_TEXT: case GLAND_HEIGHTMAP_ROTATION_PULLDOWN:*/
 
   444 			/* case GLAND_HEIGHTMAP_ROTATION_TEXT: case GLAND_HEIGHTMAP_ROTATION_PULLDOWN:*/
 
   447 				if (mode == GLWP_HEIGHTMAP) {
 
   445 				if (mode == GLWP_HEIGHTMAP) {
 
   448 					ShowDropDownMenu(this, _rotation, _patches_newgame.heightmap_rotation, GLAND_HEIGHTMAP_ROTATION_PULLDOWN, 0, 0);
 
   446 					ShowDropDownMenu(this, _rotation, _settings_newgame.game_creation.heightmap_rotation, GLAND_HEIGHTMAP_ROTATION_PULLDOWN, 0, 0);
 
   449 				} else {
 
   447 				} else {
 
   450 					ShowDropDownMenu(this, _landscape, _patches_newgame.land_generator, GLAND_LANDSCAPE_PULLDOWN, 0, 0);
 
   448 					ShowDropDownMenu(this, _landscape, _settings_newgame.game_creation.land_generator, GLAND_LANDSCAPE_PULLDOWN, 0, 0);
 
   451 				}
 
   449 				}
 
   452 				break;
 
   450 				break;
 
   453 
   451 
   454 			case GLAND_TERRAIN_PULLDOWN: // Terrain type
 
   452 			case GLAND_TERRAIN_PULLDOWN: // Terrain type
 
   455 				ShowDropDownMenu(this, _elevations, _opt_newgame.diff.terrain_type, GLAND_TERRAIN_PULLDOWN, 0, 0);
 
   453 				ShowDropDownMenu(this, _elevations, _settings_newgame.difficulty.terrain_type, GLAND_TERRAIN_PULLDOWN, 0, 0);
 
   456 				break;
 
   454 				break;
 
   457 
   455 
   458 			case GLAND_WATER_PULLDOWN: // Water quantity
 
   456 			case GLAND_WATER_PULLDOWN: // Water quantity
 
   459 				ShowDropDownMenu(this, _sea_lakes, _opt_newgame.diff.quantity_sea_lakes, GLAND_WATER_PULLDOWN, 0, 0);
 
   457 				ShowDropDownMenu(this, _sea_lakes, _settings_newgame.difficulty.quantity_sea_lakes, GLAND_WATER_PULLDOWN, 0, 0);
 
   460 				break;
 
   458 				break;
 
   461 
   459 
   462 			case GLAND_SMOOTHNESS_PULLDOWN: // Map smoothness
 
   460 			case GLAND_SMOOTHNESS_PULLDOWN: // Map smoothness
 
   463 				ShowDropDownMenu(this, _smoothness, _patches_newgame.tgen_smoothness, GLAND_SMOOTHNESS_PULLDOWN, 0, 0);
 
   461 				ShowDropDownMenu(this, _smoothness, _settings_newgame.game_creation.tgen_smoothness, GLAND_SMOOTHNESS_PULLDOWN, 0, 0);
 
   464 				break;
 
   462 				break;
 
   465 		}
 
   463 		}
 
   466 	}
 
   464 	}
 
   467 
   465 
   468 	virtual void OnMouseLoop()
 
   466 	virtual void OnMouseLoop()
 
   477 		/* the seed is unsigned, therefore atoi cannot be used.
 
   475 		/* the seed is unsigned, therefore atoi cannot be used.
 
   478 			* As 2^32 - 1 (MAX_UVALUE(uint32)) is a 'magic' value
 
   476 			* As 2^32 - 1 (MAX_UVALUE(uint32)) is a 'magic' value
 
   479 			* (use random seed) it should not be possible to be
 
   477 			* (use random seed) it should not be possible to be
 
   480 			* entered into the input field; the generate seed
 
   478 			* entered into the input field; the generate seed
 
   481 			* button can be used instead. */
 
   479 			* button can be used instead. */
 
   482 		_patches_newgame.generation_seed = minu(strtoul(this->edit_str_buf, NULL, sizeof(this->edit_str_buf) - 1), MAX_UVALUE(uint32) - 1);
 
   480 		_settings_newgame.game_creation.generation_seed = minu(strtoul(this->edit_str_buf, NULL, sizeof(this->edit_str_buf) - 1), MAX_UVALUE(uint32) - 1);
 
   483 		return state;
 
   481 		return state;
 
   484 	}
 
   482 	}
 
   485 
   483 
   486 	virtual void OnDropdownSelect(int widget, int index)
 
   484 	virtual void OnDropdownSelect(int widget, int index)
 
   487 	{
 
   485 	{
 
   488 		switch (widget) {
 
   486 		switch (widget) {
 
   489 			case GLAND_MAPSIZE_X_PULLDOWN:  _patches_newgame.map_x = index; break;
 
   487 			case GLAND_MAPSIZE_X_PULLDOWN:  _settings_newgame.game_creation.map_x = index; break;
 
   490 			case GLAND_MAPSIZE_Y_PULLDOWN:  _patches_newgame.map_y = index; break;
 
   488 			case GLAND_MAPSIZE_Y_PULLDOWN:  _settings_newgame.game_creation.map_y = index; break;
 
   491 			case GLAND_TREE_PULLDOWN:       _patches_newgame.tree_placer = index; break;
 
   489 			case GLAND_TREE_PULLDOWN:       _settings_newgame.game_creation.tree_placer = index; break;
 
   492 			case GLAND_SMOOTHNESS_PULLDOWN: _patches_newgame.tgen_smoothness = index;  break;
 
   490 			case GLAND_SMOOTHNESS_PULLDOWN: _settings_newgame.game_creation.tgen_smoothness = index;  break;
 
   493 
   491 
   494 			case GLAND_TOWN_PULLDOWN:
 
   492 			case GLAND_TOWN_PULLDOWN:
 
   495 				_opt_newgame.diff.number_towns = index;
 
   493 				_settings_newgame.difficulty.number_towns = index;
 
   496 				if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
 
   494 				if (_settings_newgame.difficulty.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
 
   497 				DoCommandP(0, 2, _opt_newgame.diff.number_towns, NULL, CMD_CHANGE_DIFFICULTY_LEVEL);
 
   495 				IConsoleSetPatchSetting("difficulty.number_towns", _settings_newgame.difficulty.number_towns);
 
   498 				break;
 
   496 				break;
 
   499 
   497 
   500 			case GLAND_INDUSTRY_PULLDOWN:
 
   498 			case GLAND_INDUSTRY_PULLDOWN:
 
   501 				_opt_newgame.diff.number_industries = index;
 
   499 				_settings_newgame.difficulty.number_industries = index;
 
   502 				if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
 
   500 				if (_settings_newgame.difficulty.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
 
   503 				DoCommandP(0, 3, _opt_newgame.diff.number_industries, NULL, CMD_CHANGE_DIFFICULTY_LEVEL);
 
   501 				IConsoleSetPatchSetting("difficulty.number_industries", _settings_newgame.difficulty.number_industries);
 
   504 				break;
 
   502 				break;
 
   505 
   503 
   506 			case GLAND_LANDSCAPE_PULLDOWN:
 
   504 			case GLAND_LANDSCAPE_PULLDOWN:
 
   507 			/* case GLAND_HEIGHTMAP_PULLDOWN: */
 
   505 			/* case GLAND_HEIGHTMAP_PULLDOWN: */
 
   508 				if (mode == GLWP_HEIGHTMAP) {
 
   506 				if (mode == GLWP_HEIGHTMAP) {
 
   509 					_patches_newgame.heightmap_rotation = index;
 
   507 					_settings_newgame.game_creation.heightmap_rotation = index;
 
   510 				} else {
 
   508 				} else {
 
   511 					_patches_newgame.land_generator = index;
 
   509 					_settings_newgame.game_creation.land_generator = index;
 
   512 				}
 
   510 				}
 
   513 				break;
 
   511 				break;
 
   514 
   512 
   515 			case GLAND_TERRAIN_PULLDOWN:
 
   513 			case GLAND_TERRAIN_PULLDOWN:
 
   516 				_opt_newgame.diff.terrain_type = index;
 
   514 				_settings_newgame.difficulty.terrain_type = index;
 
   517 				if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
 
   515 				if (_settings_newgame.difficulty.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
 
   518 				DoCommandP(0, 12, _opt_newgame.diff.terrain_type, NULL, CMD_CHANGE_DIFFICULTY_LEVEL);
 
   516 				IConsoleSetPatchSetting("difficulty.terrain_type", _settings_newgame.difficulty.terrain_type);
 
   519 				break;
 
   517 				break;
 
   520 
   518 
   521 			case GLAND_WATER_PULLDOWN:
 
   519 			case GLAND_WATER_PULLDOWN:
 
   522 				_opt_newgame.diff.quantity_sea_lakes = index;
 
   520 				_settings_newgame.difficulty.quantity_sea_lakes = index;
 
   523 				if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
 
   521 				if (_settings_newgame.difficulty.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
 
   524 				DoCommandP(0, 13, _opt_newgame.diff.quantity_sea_lakes, NULL, CMD_CHANGE_DIFFICULTY_LEVEL);
 
   522 				IConsoleSetPatchSetting("difficulty.quantity_sea_lakes", _settings_newgame.difficulty.quantity_sea_lakes);
 
   525 				break;
 
   523 				break;
 
   526 		}
 
   524 		}
 
   527 		this->SetDirty();
 
   525 		this->SetDirty();
 
   528 	}
 
   526 	}
 
   529 
   527 
   533 			int32 value = atoi(str);
 
   531 			int32 value = atoi(str);
 
   534 
   532 
   535 			switch (this->widget_id) {
 
   533 			switch (this->widget_id) {
 
   536 				case GLAND_START_DATE_TEXT:
 
   534 				case GLAND_START_DATE_TEXT:
 
   537 					this->InvalidateWidget(GLAND_START_DATE_TEXT);
 
   535 					this->InvalidateWidget(GLAND_START_DATE_TEXT);
 
   538 					_patches_newgame.starting_year = Clamp(value, MIN_YEAR, MAX_YEAR);
 
   536 					_settings_newgame.game_creation.starting_year = Clamp(value, MIN_YEAR, MAX_YEAR);
 
   539 					break;
 
   537 					break;
 
   540 
   538 
   541 				case GLAND_SNOW_LEVEL_TEXT:
 
   539 				case GLAND_SNOW_LEVEL_TEXT:
 
   542 					this->InvalidateWidget(GLAND_SNOW_LEVEL_TEXT);
 
   540 					this->InvalidateWidget(GLAND_SNOW_LEVEL_TEXT);
 
   543 					_patches_newgame.snow_line_height = Clamp(value, 2, MAX_SNOWLINE_HEIGHT);
 
   541 					_settings_newgame.game_creation.snow_line_height = Clamp(value, 2, MAX_SNOWLINE_HEIGHT);
 
   544 					break;
 
   542 					break;
 
   545 			}
 
   543 			}
 
   546 
   544 
   547 			this->SetDirty();
 
   545 			this->SetDirty();
 
   548 		}
 
   546 		}
 
   569 	uint y = 0;
 
   567 	uint y = 0;
 
   570 
   568 
   571 	DeleteWindowByClass(WC_GENERATE_LANDSCAPE);
 
   569 	DeleteWindowByClass(WC_GENERATE_LANDSCAPE);
 
   572 
   570 
   573 	/* Always give a new seed if not editor */
 
   571 	/* Always give a new seed if not editor */
 
   574 	if (_game_mode != GM_EDITOR) _patches_newgame.generation_seed = InteractiveRandom();
 
   572 	if (_game_mode != GM_EDITOR) _settings_newgame.game_creation.generation_seed = InteractiveRandom();
 
   575 
   573 
   576 	if (mode == GLWP_HEIGHTMAP) {
 
   574 	if (mode == GLWP_HEIGHTMAP) {
 
   577 		/* If the function returns negative, it means there was a problem loading the heightmap */
 
   575 		/* If the function returns negative, it means there was a problem loading the heightmap */
 
   578 		if (!GetHeightmapDimensions(_file_to_saveload.name, &x, &y)) return;
 
   576 		if (!GetHeightmapDimensions(_file_to_saveload.name, &x, &y)) return;
 
   579 	}
 
   577 	}
 
   599 	_ShowGenerateLandscape(GLWP_HEIGHTMAP);
 
   597 	_ShowGenerateLandscape(GLWP_HEIGHTMAP);
 
   600 }
 
   598 }
 
   601 
   599 
   602 void StartScenarioEditor()
 
   600 void StartScenarioEditor()
 
   603 {
 
   601 {
 
   604 	if (_patches_newgame.town_layout == TL_NO_ROADS) {
 
   602 	if (_settings_newgame.economy.town_layout == TL_NO_ROADS) {
 
   605 		_patches_newgame.town_layout = TL_ORIGINAL;
 
   603 		_settings_newgame.economy.town_layout = TL_ORIGINAL;
 
   606 	}
 
   604 	}
 
   607 
   605 
   608 	StartGeneratingLandscape(GLWP_SCENARIO);
 
   606 	StartGeneratingLandscape(GLWP_SCENARIO);
 
   609 }
 
   607 }
 
   610 
   608 
   611 void StartNewGameWithoutGUI(uint seed)
 
   609 void StartNewGameWithoutGUI(uint seed)
 
   612 {
 
   610 {
 
   613 	/* GenerateWorld takes care of the possible GENERATE_NEW_SEED value in 'seed' */
 
   611 	/* GenerateWorld takes care of the possible GENERATE_NEW_SEED value in 'seed' */
 
   614 	_patches_newgame.generation_seed = seed;
 
   612 	_settings_newgame.game_creation.generation_seed = seed;
 
   615 
   613 
   616 	StartGeneratingLandscape(GLWP_GENERATE);
 
   614 	StartGeneratingLandscape(GLWP_GENERATE);
 
   617 }
 
   615 }
 
   618 
   616 
   619 enum CreateScenarioWindowWidgets {
 
   617 enum CreateScenarioWindowWidgets {
 
   642 {
 
   640 {
 
   643 	uint widget_id;
 
   641 	uint widget_id;
 
   644 
   642 
   645 	CreateScenarioWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)
 
   643 	CreateScenarioWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)
 
   646 	{
 
   644 	{
 
   647 		this->LowerWidget(_opt_newgame.landscape + CSCEN_TEMPERATE);
 
   645 		this->LowerWidget(_settings_newgame.game_creation.landscape + CSCEN_TEMPERATE);
 
       
   646 		this->FindWindowPlacementAndResize(desc);
 
   648 	}
 
   647 	}
 
   649 
   648 
   650 	virtual void OnPaint()
 
   649 	virtual void OnPaint()
 
   651 	{
 
   650 	{
 
   652 		this->SetWidgetDisabledState(CSCEN_START_DATE_DOWN,       _patches_newgame.starting_year <= MIN_YEAR);
 
   651 		this->SetWidgetDisabledState(CSCEN_START_DATE_DOWN,       _settings_newgame.game_creation.starting_year <= MIN_YEAR);
 
   653 		this->SetWidgetDisabledState(CSCEN_START_DATE_UP,         _patches_newgame.starting_year >= MAX_YEAR);
 
   652 		this->SetWidgetDisabledState(CSCEN_START_DATE_UP,         _settings_newgame.game_creation.starting_year >= MAX_YEAR);
 
   654 		this->SetWidgetDisabledState(CSCEN_FLAT_LAND_HEIGHT_DOWN, _patches_newgame.se_flat_world_height <= 0);
 
   653 		this->SetWidgetDisabledState(CSCEN_FLAT_LAND_HEIGHT_DOWN, _settings_newgame.game_creation.se_flat_world_height <= 0);
 
   655 		this->SetWidgetDisabledState(CSCEN_FLAT_LAND_HEIGHT_UP,   _patches_newgame.se_flat_world_height >= MAX_TILE_HEIGHT);
 
   654 		this->SetWidgetDisabledState(CSCEN_FLAT_LAND_HEIGHT_UP,   _settings_newgame.game_creation.se_flat_world_height >= MAX_TILE_HEIGHT);
 
   656 
   655 
   657 		this->SetWidgetLoweredState(CSCEN_TEMPERATE, _opt_newgame.landscape == LT_TEMPERATE);
 
   656 		this->SetWidgetLoweredState(CSCEN_TEMPERATE, _settings_newgame.game_creation.landscape == LT_TEMPERATE);
 
   658 		this->SetWidgetLoweredState(CSCEN_ARCTIC,    _opt_newgame.landscape == LT_ARCTIC);
 
   657 		this->SetWidgetLoweredState(CSCEN_ARCTIC,    _settings_newgame.game_creation.landscape == LT_ARCTIC);
 
   659 		this->SetWidgetLoweredState(CSCEN_TROPICAL,  _opt_newgame.landscape == LT_TROPIC);
 
   658 		this->SetWidgetLoweredState(CSCEN_TROPICAL,  _settings_newgame.game_creation.landscape == LT_TROPIC);
 
   660 		this->SetWidgetLoweredState(CSCEN_TOYLAND,   _opt_newgame.landscape == LT_TOYLAND);
 
   659 		this->SetWidgetLoweredState(CSCEN_TOYLAND,   _settings_newgame.game_creation.landscape == LT_TOYLAND);
 
   661 
   660 
   662 		/* Set parameters for widget text that requires them */
 
   661 		/* Set parameters for widget text that requires them */
 
   663 		SetDParam(0, ConvertYMDToDate(_patches_newgame.starting_year, 0, 1)); // CSCEN_START_DATE_TEXT
 
   662 		SetDParam(0, ConvertYMDToDate(_settings_newgame.game_creation.starting_year, 0, 1)); // CSCEN_START_DATE_TEXT
 
   664 		SetDParam(1, 1 << _patches_newgame.map_x); // CSCEN_MAPSIZE_X_PULLDOWN
 
   663 		SetDParam(1, 1 << _settings_newgame.game_creation.map_x); // CSCEN_MAPSIZE_X_PULLDOWN
 
   665 		SetDParam(2, 1 << _patches_newgame.map_y); // CSCEN_MAPSIZE_Y_PULLDOWN
 
   664 		SetDParam(2, 1 << _settings_newgame.game_creation.map_y); // CSCEN_MAPSIZE_Y_PULLDOWN
 
   666 		SetDParam(3, _patches_newgame.se_flat_world_height); // CSCEN_FLAT_LAND_HEIGHT_TEXT
 
   665 		SetDParam(3, _settings_newgame.game_creation.se_flat_world_height); // CSCEN_FLAT_LAND_HEIGHT_TEXT
 
   667 
   666 
   668 		this->DrawWidgets();
 
   667 		this->DrawWidgets();
 
   669 	}
 
   668 	}
 
   670 
   669 
   671 	virtual void OnClick(Point pt, int widget)
 
   670 	virtual void OnClick(Point pt, int widget)
 
   673 		switch (widget) {
 
   672 		switch (widget) {
 
   674 			case CSCEN_TEMPERATE:
 
   673 			case CSCEN_TEMPERATE:
 
   675 			case CSCEN_ARCTIC:
 
   674 			case CSCEN_ARCTIC:
 
   676 			case CSCEN_TROPICAL:
 
   675 			case CSCEN_TROPICAL:
 
   677 			case CSCEN_TOYLAND:
 
   676 			case CSCEN_TOYLAND:
 
   678 				this->RaiseWidget(_opt_newgame.landscape + CSCEN_TEMPERATE);
 
   677 				this->RaiseWidget(_settings_newgame.game_creation.landscape + CSCEN_TEMPERATE);
 
   679 				SetNewLandscapeType(widget - CSCEN_TEMPERATE);
 
   678 				SetNewLandscapeType(widget - CSCEN_TEMPERATE);
 
   680 				break;
 
   679 				break;
 
   681 
   680 
   682 			case CSCEN_MAPSIZE_X_PULLDOWN: // Mapsize X
 
   681 			case CSCEN_MAPSIZE_X_PULLDOWN: // Mapsize X
 
   683 				ShowDropDownList(this, BuildMapsizeDropDown(), _patches_newgame.map_x, CSCEN_MAPSIZE_X_PULLDOWN);
 
   682 				ShowDropDownList(this, BuildMapsizeDropDown(), _settings_newgame.game_creation.map_x, CSCEN_MAPSIZE_X_PULLDOWN);
 
   684 				break;
 
   683 				break;
 
   685 
   684 
   686 			case CSCEN_MAPSIZE_Y_PULLDOWN: // Mapsize Y
 
   685 			case CSCEN_MAPSIZE_Y_PULLDOWN: // Mapsize Y
 
   687 				ShowDropDownList(this, BuildMapsizeDropDown(), _patches_newgame.map_y, CSCEN_MAPSIZE_Y_PULLDOWN);
 
   686 				ShowDropDownList(this, BuildMapsizeDropDown(), _settings_newgame.game_creation.map_y, CSCEN_MAPSIZE_Y_PULLDOWN);
 
   688 				break;
 
   687 				break;
 
   689 
   688 
   690 			case CSCEN_EMPTY_WORLD: // Empty world / flat world
 
   689 			case CSCEN_EMPTY_WORLD: // Empty world / flat world
 
   691 				StartGeneratingLandscape(GLWP_SCENARIO);
 
   690 				StartGeneratingLandscape(GLWP_SCENARIO);
 
   692 				break;
 
   691 				break;
 
   700 				/* Don't allow too fast scrolling */
 
   699 				/* Don't allow too fast scrolling */
 
   701 				if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
 
   700 				if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
 
   702 					this->HandleButtonClick(widget);
 
   701 					this->HandleButtonClick(widget);
 
   703 					this->SetDirty();
 
   702 					this->SetDirty();
 
   704 
   703 
   705 					_patches_newgame.starting_year = Clamp(_patches_newgame.starting_year + widget - CSCEN_START_DATE_TEXT, MIN_YEAR, MAX_YEAR);
 
   704 					_settings_newgame.game_creation.starting_year = Clamp(_settings_newgame.game_creation.starting_year + widget - CSCEN_START_DATE_TEXT, MIN_YEAR, MAX_YEAR);
 
   706 				}
 
   705 				}
 
   707 				_left_button_clicked = false;
 
   706 				_left_button_clicked = false;
 
   708 				break;
 
   707 				break;
 
   709 
   708 
   710 			case CSCEN_START_DATE_TEXT: // Year text
 
   709 			case CSCEN_START_DATE_TEXT: // Year text
 
   711 				this->widget_id = CSCEN_START_DATE_TEXT;
 
   710 				this->widget_id = CSCEN_START_DATE_TEXT;
 
   712 				SetDParam(0, _patches_newgame.starting_year);
 
   711 				SetDParam(0, _settings_newgame.game_creation.starting_year);
 
   713 				ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_START_DATE_QUERY_CAPT, 8, 100, this, CS_NUMERAL);
 
   712 				ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_START_DATE_QUERY_CAPT, 8, 100, this, CS_NUMERAL);
 
   714 				break;
 
   713 				break;
 
   715 
   714 
   716 			case CSCEN_FLAT_LAND_HEIGHT_DOWN:
 
   715 			case CSCEN_FLAT_LAND_HEIGHT_DOWN:
 
   717 			case CSCEN_FLAT_LAND_HEIGHT_UP: // Height level buttons
 
   716 			case CSCEN_FLAT_LAND_HEIGHT_UP: // Height level buttons
 
   718 				/* Don't allow too fast scrolling */
 
   717 				/* Don't allow too fast scrolling */
 
   719 				if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
 
   718 				if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
 
   720 					this->HandleButtonClick(widget);
 
   719 					this->HandleButtonClick(widget);
 
   721 					this->SetDirty();
 
   720 					this->SetDirty();
 
   722 
   721 
   723 					_patches_newgame.se_flat_world_height = Clamp(_patches_newgame.se_flat_world_height + widget - CSCEN_FLAT_LAND_HEIGHT_TEXT, 0, MAX_TILE_HEIGHT);
 
   722 					_settings_newgame.game_creation.se_flat_world_height = Clamp(_settings_newgame.game_creation.se_flat_world_height + widget - CSCEN_FLAT_LAND_HEIGHT_TEXT, 0, MAX_TILE_HEIGHT);
 
   724 				}
 
   723 				}
 
   725 				_left_button_clicked = false;
 
   724 				_left_button_clicked = false;
 
   726 				break;
 
   725 				break;
 
   727 
   726 
   728 			case CSCEN_FLAT_LAND_HEIGHT_TEXT: // Height level text
 
   727 			case CSCEN_FLAT_LAND_HEIGHT_TEXT: // Height level text
 
   729 				this->widget_id = CSCEN_FLAT_LAND_HEIGHT_TEXT;
 
   728 				this->widget_id = CSCEN_FLAT_LAND_HEIGHT_TEXT;
 
   730 				SetDParam(0, _patches_newgame.se_flat_world_height);
 
   729 				SetDParam(0, _settings_newgame.game_creation.se_flat_world_height);
 
   731 				ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_FLAT_WORLD_HEIGHT_QUERY_CAPT, 3, 100, this, CS_NUMERAL);
 
   730 				ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_FLAT_WORLD_HEIGHT_QUERY_CAPT, 3, 100, this, CS_NUMERAL);
 
   732 				break;
 
   731 				break;
 
   733 		}
 
   732 		}
 
   734 	}
 
   733 	}
 
   735 
   734 
   736 	virtual void OnDropdownSelect(int widget, int index)
 
   735 	virtual void OnDropdownSelect(int widget, int index)
 
   737 	{
 
   736 	{
 
   738 		switch (widget) {
 
   737 		switch (widget) {
 
   739 			case CSCEN_MAPSIZE_X_PULLDOWN: _patches_newgame.map_x = index; break;
 
   738 			case CSCEN_MAPSIZE_X_PULLDOWN: _settings_newgame.game_creation.map_x = index; break;
 
   740 			case CSCEN_MAPSIZE_Y_PULLDOWN: _patches_newgame.map_y = index; break;
 
   739 			case CSCEN_MAPSIZE_Y_PULLDOWN: _settings_newgame.game_creation.map_y = index; break;
 
   741 		}
 
   740 		}
 
   742 		this->SetDirty();
 
   741 		this->SetDirty();
 
   743 	}
 
   742 	}
 
   744 
   743 
   745 	virtual void OnQueryTextFinished(char *str)
 
   744 	virtual void OnQueryTextFinished(char *str)
 
   748 			int32 value = atoi(str);
 
   747 			int32 value = atoi(str);
 
   749 
   748 
   750 			switch (this->widget_id) {
 
   749 			switch (this->widget_id) {
 
   751 				case CSCEN_START_DATE_TEXT:
 
   750 				case CSCEN_START_DATE_TEXT:
 
   752 					this->InvalidateWidget(CSCEN_START_DATE_TEXT);
 
   751 					this->InvalidateWidget(CSCEN_START_DATE_TEXT);
 
   753 					_patches_newgame.starting_year = Clamp(value, MIN_YEAR, MAX_YEAR);
 
   752 					_settings_newgame.game_creation.starting_year = Clamp(value, MIN_YEAR, MAX_YEAR);
 
   754 					break;
 
   753 					break;
 
   755 
   754 
   756 				case CSCEN_FLAT_LAND_HEIGHT_TEXT:
 
   755 				case CSCEN_FLAT_LAND_HEIGHT_TEXT:
 
   757 					this->InvalidateWidget(CSCEN_FLAT_LAND_HEIGHT_TEXT);
 
   756 					this->InvalidateWidget(CSCEN_FLAT_LAND_HEIGHT_TEXT);
 
   758 					_patches_newgame.se_flat_world_height = Clamp(value, 0, MAX_TILE_HEIGHT);
 
   757 					_settings_newgame.game_creation.se_flat_world_height = Clamp(value, 0, MAX_TILE_HEIGHT);
 
   759 					break;
 
   758 					break;
 
   760 			}
 
   759 			}
 
   761 
   760 
   762 			this->SetDirty();
 
   761 			this->SetDirty();
 
   763 		}
 
   762 		}
 
   848 		GPWW_BACKGROUND,
 
   847 		GPWW_BACKGROUND,
 
   849 		GPWW_ABORT,
 
   848 		GPWW_ABORT,
 
   850 	};
 
   849 	};
 
   851 
   850 
   852 public:
 
   851 public:
 
   853 	GenerateProgressWindow() : Window(&_generate_progress_desc) {};
 
   852 	GenerateProgressWindow() : Window(&_generate_progress_desc)
 
       
   853 	{
 
       
   854 		this->FindWindowPlacementAndResize(&_generate_progress_desc);
 
       
   855 	}
 
   854 
   856 
   855 	virtual void OnClick(Point pt, int widget)
 
   857 	virtual void OnClick(Point pt, int widget)
 
   856 	{
 
   858 	{
 
   857 		switch (widget) {
 
   859 		switch (widget) {
 
   858 			case GPWW_ABORT:
 
   860 			case GPWW_ABORT:
openttd-ottdgrfs