311 	switch (prop) {

   306 	for (int i = 0; i < numinfo; i++) {

   312 		case 0x05: // Track type

   307 		EngineInfo *ei       = &_engine_info[engine + i];

   313 			FOR_EACH_OBJECT {

   308 		RailVehicleInfo *rvi = &_rail_vehicle_info[engine + i];

   309 

   310 		switch (prop) {

   311 			case 0x05: { // Track type

   317 					case 0: rvi[i].railtype = rvi[i].engclass >= 2 ? RAILTYPE_ELECTRIC : RAILTYPE_RAIL; break;

   315 					case 0: rvi->railtype = rvi->engclass >= 2 ? RAILTYPE_ELECTRIC : RAILTYPE_RAIL; break;

   318 					case 1: rvi[i].railtype = RAILTYPE_MONO; break;

   316 					case 1: rvi->railtype = RAILTYPE_MONO; break;

   319 					case 2: rvi[i].railtype = RAILTYPE_MAGLEV; break;

   317 					case 2: rvi->railtype = RAILTYPE_MAGLEV; break;

   324 			}

   322 			} break;

   325 			break;

   323 

   326 

   324 			case 0x08: // AI passenger service

   327 		case 0x08: // AI passenger service

   325 				/* @todo missing feature */

   328 			/* @todo missing feature */

   326 				grf_load_byte(&buf);

   329 			FOR_EACH_OBJECT grf_load_byte(&buf);

   327 				ret = true;

   330 			ret = true;

   328 				break;

   331 			break;

   329 

   332 

   330 			case 0x09: { // Speed (1 unit is 1 kmh)

   333 		case 0x09: // Speed (1 unit is 1 kmh)

   334 			FOR_EACH_OBJECT {

   338 				rvi[i].max_speed = speed;

   334 				rvi->max_speed = speed;

   339 			}

   335 			} break;

   340 			break;

   336 

   341 

   337 			case 0x0B: { // Power

   342 		case 0x0B: // Power

   343 			FOR_EACH_OBJECT {

   346 				if (rvi[i].railveh_type == RAILVEH_MULTIHEAD) power /= 2;

   340 				if (rvi->railveh_type == RAILVEH_MULTIHEAD) power /= 2;

   347 

   341 

   348 				rvi[i].power = power;

   342 				rvi->power = power;

   350 			}

   344 			} break;

   351 			break;

   345 

   352 

   346 			case 0x0D: { // Running cost factor

   353 		case 0x0D: // Running cost factor

   354 			FOR_EACH_OBJECT {

   357 				if (rvi[i].railveh_type == RAILVEH_MULTIHEAD) runcostfact /= 2;

   349 				if (rvi->railveh_type == RAILVEH_MULTIHEAD) runcostfact /= 2;

   358 

   350 

   359 				rvi[i].running_cost_base = runcostfact;

   351 				rvi->running_cost_base = runcostfact;

   360 			}

   352 			} break;

   361 			break;

   353 

   362 

   354 			case 0x0E: { // Running cost base

   363 		case 0x0E: // Running cost base

   364 			FOR_EACH_OBJECT {

   368 					case 0x4C30: rvi[i].running_cost_class = 0; break;

   358 					case 0x4C30: rvi->running_cost_class = 0; break;

   369 					case 0x4C36: rvi[i].running_cost_class = 1; break;

   359 					case 0x4C36: rvi->running_cost_class = 1; break;

   370 					case 0x4C3C: rvi[i].running_cost_class = 2; break;

   360 					case 0x4C3C: rvi->running_cost_class = 2; break;

   376 			}

   366 			} break;

   377 			break;

   367 

   378 

   368 			case 0x12: { // Sprite ID

   379 		case 0x12: // Sprite ID

   380 			FOR_EACH_OBJECT {

   387 				rvi[i].image_index = spriteid;

   375 				rvi->image_index = spriteid;

   388 			}

   376 			} break;

   389 			break;

   377 

   390 

   378 			case 0x13: { // Dual-headed

   391 		case 0x13: // Dual-headed

   392 			FOR_EACH_OBJECT {

   396 					if (rvi[i].railveh_type != RAILVEH_MULTIHEAD) {

   382 					if (rvi->railveh_type != RAILVEH_MULTIHEAD) {

   398 						rvi[i].power /= 2;

   384 						rvi->power /= 2;

   399 						rvi[i].running_cost_base /= 2;

   385 						rvi->running_cost_base /= 2;

   401 					rvi[i].railveh_type = RAILVEH_MULTIHEAD;

   387 					rvi->railveh_type = RAILVEH_MULTIHEAD;

   403 					if (rvi[i].railveh_type == RAILVEH_MULTIHEAD) {

   389 					if (rvi->railveh_type == RAILVEH_MULTIHEAD) {

   405 						rvi[i].power *= 2;

   391 						rvi->power *= 2;

   406 						rvi[i].running_cost_base *= 2;

   392 						rvi->running_cost_base *= 2;

   408 					rvi[i].railveh_type = rvi[i].power == 0 ?

   394 					rvi->railveh_type = rvi->power == 0 ?

   411 			}

   397 			} break;

   412 			break;

   398 

   413 

   399 			case 0x14: // Cargo capacity

   414 		case 0x14: // Cargo capacity

   400 				rvi->capacity = grf_load_byte(&buf);

   415 			FOR_EACH_OBJECT rvi[i].capacity = grf_load_byte(&buf);

   401 				break;

   416 			break;

   402 

   417 

   403 			case 0x15: { // Cargo type

   418 		case 0x15: // Cargo type

   419 			FOR_EACH_OBJECT {

   423 					rvi[i].cargo_type = ctype;

   407 					rvi->cargo_type = ctype;

   425 					rvi[i].cargo_type = CT_INVALID;

   409 					rvi->cargo_type = CT_INVALID;

   428 			}

   412 			} break;

   429 			break;

   413 

   430 

   414 			case 0x16: // Weight

   431 		case 0x16: // Weight

   415 				SB(rvi->weight, 0, 8, grf_load_byte(&buf));

   432 			FOR_EACH_OBJECT SB(rvi[i].weight, 0, 8, grf_load_byte(&buf));

   416 				break;

   433 			break;

   417 

   434 

   418 			case 0x17: // Cost factor

   435 		case 0x17: // Cost factor

   419 				rvi->base_cost = grf_load_byte(&buf);

   436 			FOR_EACH_OBJECT rvi[i].base_cost = grf_load_byte(&buf);

   420 				break;

   437 			break;

   421 

   438 

   422 			case 0x18: // AI rank

   439 		case 0x18: // AI rank

   423 				rvi->ai_rank = grf_load_byte(&buf);

   440 			FOR_EACH_OBJECT rvi[i].ai_rank = grf_load_byte(&buf);

   424 				break;

   441 			break;

   425 

   442 

   426 			case 0x19: { // Engine traction type

   443 		case 0x19: // Engine traction type

   427 				/* What do the individual numbers mean?

   444 			/* What do the individual numbers mean?

   428 				 * 0x00 .. 0x07: Steam

   445 			 * 0x00 .. 0x07: Steam

   429 				 * 0x08 .. 0x27: Diesel

   446 			 * 0x08 .. 0x27: Diesel

   430 				 * 0x28 .. 0x31: Electric

   447 			 * 0x28 .. 0x31: Electric

   431 				 * 0x32 .. 0x37: Monorail

   448 			 * 0x32 .. 0x37: Monorail

   432 				 * 0x38 .. 0x41: Maglev

   449 			 * 0x38 .. 0x41: Maglev

   433 				 */

   450 			 */

   451 			FOR_EACH_OBJECT {

   468 				if (rvi[i].railtype == RAILTYPE_RAIL     && engclass >= EC_ELECTRIC) rvi[i].railtype = RAILTYPE_ELECTRIC;

   450 				if (rvi->railtype == RAILTYPE_RAIL     && engclass >= EC_ELECTRIC) rvi->railtype = RAILTYPE_ELECTRIC;

   469 				if (rvi[i].railtype == RAILTYPE_ELECTRIC && engclass  < EC_ELECTRIC) rvi[i].railtype = RAILTYPE_RAIL;

   451 				if (rvi->railtype == RAILTYPE_ELECTRIC && engclass  < EC_ELECTRIC) rvi->railtype = RAILTYPE_RAIL;

   470 

   452 

   471 				rvi[i].engclass = engclass;

   453 				rvi->engclass = engclass;

   472 			}

   454 			} break;

   473 			break;

   455 

   474 

   456 			case 0x1A: { // Alter purchase list sort order

   475 		case 0x1A: // Alter purchase list sort order

   476 			FOR_EACH_OBJECT {

   484 			}

   464 			} break;

   485 			break;

   465 

   486 

   466 			case 0x1B: // Powered wagons power bonus

   487 		case 0x1B: // Powered wagons power bonus

   467 				rvi->pow_wag_power = grf_load_word(&buf);

   488 			FOR_EACH_OBJECT rvi[i].pow_wag_power = grf_load_word(&buf);

   468 				break;

   489 			break;

   469 

   490 

   470 			case 0x1C: // Refit cost

   491 		case 0x1C: // Refit cost

   471 				ei->refit_cost = grf_load_byte(&buf);

   492 			FOR_EACH_OBJECT ei[i].refit_cost = grf_load_byte(&buf);

   472 				break;

   493 			break;

   473 

   494 

   474 			case 0x1D: // Refit cargo

   495 		case 0x1D: // Refit cargo

   475 				ei->refit_mask = grf_load_dword(&buf);

   496 			FOR_EACH_OBJECT ei[i].refit_mask = grf_load_dword(&buf);

   476 				break;

   497 			break;

   477 

   498 

   478 			case 0x1E: // Callback

   499 		case 0x1E: // Callback

   479 				ei->callbackmask = grf_load_byte(&buf);

   500 			FOR_EACH_OBJECT ei[i].callbackmask = grf_load_byte(&buf);

   480 				break;

   501 			break;

   481 

   502 

   482 			case 0x1F: // Tractive effort coefficient

   503 		case 0x1F: // Tractive effort coefficient

   483 				rvi->tractive_effort = grf_load_byte(&buf);

   504 			FOR_EACH_OBJECT rvi[i].tractive_effort = grf_load_byte(&buf);

   484 				break;

   505 			break;

   485 

   506 

   486 			case 0x21: // Shorter vehicle

   507 		case 0x21: // Shorter vehicle

   487 				rvi->shorten_factor = grf_load_byte(&buf);

   508 			FOR_EACH_OBJECT rvi[i].shorten_factor = grf_load_byte(&buf);

   488 				break;

   509 			break;

   489 

   510 

   490 			case 0x22: // Visual effect

   511 		case 0x22: // Visual effect

   491 				/* see note in engine.h about rvi->visual_effect */

   512 			/* see note in engine.h about rvi->visual_effect */

   492 				rvi->visual_effect = grf_load_byte(&buf);

   513 			FOR_EACH_OBJECT rvi[i].visual_effect = grf_load_byte(&buf);

   493 				break;

   514 			break;

   494 

   515 

   495 			case 0x23: // Powered wagons weight bonus

   516 		case 0x23: // Powered wagons weight bonus

   496 				rvi->pow_wag_weight = grf_load_byte(&buf);

   517 			FOR_EACH_OBJECT rvi[i].pow_wag_weight = grf_load_byte(&buf);

   497 				break;

   518 			break;

   498 

   519 

   499 			case 0x24: { // High byte of vehicle weight

   520 		case 0x24: // High byte of vehicle weight

   521 			FOR_EACH_OBJECT {

   527 					SB(rvi[i].weight, 8, 8, weight);

   505 					SB(rvi->weight, 8, 8, weight);

   528 				}

   506 				}

   529 			}

   507 			} break;

   530 			break;

   508 

   531 

   509 			case 0x25: // User-defined bit mask to set when checking veh. var. 42

   532 		case 0x25: // User-defined bit mask to set when checking veh. var. 42

   510 				rvi->user_def_data = grf_load_byte(&buf);

   533 			FOR_EACH_OBJECT rvi[i].user_def_data = grf_load_byte(&buf);

   511 				break;

   534 			break;

   512 

   535 

   513 			case 0x26: // Retire vehicle early

   536 		case 0x26: // Retire vehicle early

   514 				ei->retire_early = grf_load_byte(&buf);

   537 			FOR_EACH_OBJECT ei[i].retire_early = grf_load_byte(&buf);

   515 				break;

   538 			break;

   516 

   539 

   517 			case 0x27: // Miscellaneous flags

   540 		case 0x27: // Miscellaneous flags

   518 				ei->misc_flags = grf_load_byte(&buf);

   541 			FOR_EACH_OBJECT {

   519 				_loaded_newgrf_features.has_2CC |= HASBIT(ei->misc_flags, EF_USES_2CC);

   542 				ei[i].misc_flags = grf_load_byte(&buf);

   520 				break;

   543 				_loaded_newgrf_features.has_2CC |= HASBIT(ei[i].misc_flags, EF_USES_2CC);

   521 

   544 			}

   522 			case 0x28: // Cargo classes allowed

   545 			break;

   523 				cargo_allowed[engine + i] = grf_load_word(&buf);

   546 

   524 				break;

   547 		case 0x28: // Cargo classes allowed

   525 

   548 			FOR_EACH_OBJECT cargo_allowed[engine + i] = grf_load_word(&buf);

   526 			case 0x29: // Cargo classes disallowed

   549 			break;

   527 				cargo_disallowed[engine + i] = grf_load_word(&buf);

   550 

   528 				break;

   551 		case 0x29: // Cargo classes disallowed

   529 

   552 			FOR_EACH_OBJECT cargo_disallowed[engine + i] = grf_load_word(&buf);

   530 			case 0x2A: // Long format introduction date (days since year 0)

   553 			break;

   531 				ei->base_intro = grf_load_dword(&buf);

   554 

   532 				break;

   555 		case 0x2A: // Long format introduction date (days since year 0)

   533 

   556 			FOR_EACH_OBJECT ei[i].base_intro = grf_load_dword(&buf);

   534 			/* @todo air drag and retire vehicle early

   557 			break;

   535 			 * Fall-through for unimplemented one byte long properties. */

   558 

   536 			case 0x20: // Air drag

   559 		/* @todo air drag and retire vehicle early

   537 				grf_load_byte(&buf);

   560 		 * Fall-through for unimplemented one byte long properties. */

   538 				ret = true;

   561 		case 0x20: // Air drag

   539 				break;

   562 			FOR_EACH_OBJECT grf_load_byte(&buf);

   540 

   563 			ret = true;

   541 			default:

   564 			break;

   542 				ret = true;

   565 

   543 				break;

   566 		default:

   544 		}

   567 			ret = true;

   545 	}

   568 			break;

   546 

   569 	}

   582 	switch (prop) {

   556 	for (int i = 0; i < numinfo; i++) {

   583 		case 0x08: // Speed (1 unit is 0.5 kmh)

   557 		EngineInfo *ei       = &_engine_info[ROAD_ENGINES_INDEX + engine + i];

   584 			FOR_EACH_OBJECT rvi[i].max_speed = grf_load_byte(&buf);

   558 		RoadVehicleInfo *rvi = &_road_vehicle_info[engine + i];

   585 			break;

   559 

   586 

   560 		switch (prop) {

   587 		case 0x09: // Running cost factor

   561 			case 0x08: // Speed (1 unit is 0.5 kmh)

   588 			FOR_EACH_OBJECT rvi[i].running_cost = grf_load_byte(&buf);

   562 				rvi->max_speed = grf_load_byte(&buf);

   589 			break;

   563 				break;

   590 

   564 

   591 		case 0x0A: // Running cost base

   565 			case 0x09: // Running cost factor

   592 			/* @todo : I have no idea. --pasky

   566 				rvi->running_cost = grf_load_byte(&buf);

   593 			 * I THINK it is used for overriding the base cost of all road vehicle (_price.roadveh_base) --belugas */

   567 				break;

   594 			FOR_EACH_OBJECT grf_load_dword(&buf);

   568 

   595 			ret = true;

   569 			case 0x0A: // Running cost base

   596 			break;

   570 				/* @todo : I have no idea. --pasky

   597 

   571 				 * I THINK it is used for overriding the base cost of all road vehicle (_price.roadveh_base) --belugas */

   598 		case 0x0E: // Sprite ID

   572 				grf_load_dword(&buf);

   599 			FOR_EACH_OBJECT {

   573 				ret = true;

   574 				break;

   575 

   576 			case 0x0E: { // Sprite ID

   607 				rvi[i].image_index = spriteid;

   584 				rvi->image_index = spriteid;

   608 			}

   585 			} break;

   609 			break;

   586 

   610 

   587 			case 0x0F: // Cargo capacity

   611 		case 0x0F: // Cargo capacity

   588 				rvi->capacity = grf_load_byte(&buf);

   612 			FOR_EACH_OBJECT rvi[i].capacity = grf_load_byte(&buf);

   589 				break;

   613 			break;

   590 

   614 

   591 			case 0x10: { // Cargo type

   615 		case 0x10: // Cargo type

   616 			FOR_EACH_OBJECT {

   620 					rvi[i].cargo_type = cargo;

   595 					rvi->cargo_type = cargo;

   622 					rvi[i].cargo_type = CT_INVALID;

   597 					rvi->cargo_type = CT_INVALID;

   625 			}

   600 			} break;

   626 			break;

   601 

   627 

   602 			case 0x11: // Cost factor

   628 		case 0x11: // Cost factor

   603 				rvi->base_cost = grf_load_byte(&buf); // ?? is it base_cost?

   629 			FOR_EACH_OBJECT rvi[i].base_cost = grf_load_byte(&buf); // ?? is it base_cost?

   604 				break;

   630 			break;

   605 

   631 

   606 			case 0x12: // SFX

   632 		case 0x12: // SFX

   607 				rvi->sfx = (SoundFx)grf_load_byte(&buf);

   633 			FOR_EACH_OBJECT rvi[i].sfx = (SoundFx)grf_load_byte(&buf);

   608 				break;

   634 			break;

   609 

   635 

   610 			case 0x13: // Power in 10hp

   636 		case 0x13: // Power in 10hp

   611 			case 0x14: // Weight in 1/4 tons

   637 		case 0x14: // Weight in 1/4 tons

   612 			case 0x15: // Speed in mph*0.8

   638 		case 0x15: // Speed in mph*0.8

   613 				/* TODO: Support for road vehicles realistic power

   639 			/* TODO: Support for road vehicles realistic power

   614 				 * computations (called rvpower in TTDPatch) is just

   640 			 * computations (called rvpower in TTDPatch) is just

   615 				 * missing in OTTD yet. --pasky */

   641 			 * missing in OTTD yet. --pasky */

   616 				grf_load_byte(&buf);

   642 			FOR_EACH_OBJECT grf_load_byte(&buf);

   617 				ret = true;

   643 			ret = true;

   618 				break;

   644 			break;

   619 

   645 

   620 			case 0x16: // Cargos available for refitting

   646 		case 0x16: // Cargos available for refitting

   621 				ei->refit_mask = grf_load_dword(&buf);

   647 			FOR_EACH_OBJECT ei[i].refit_mask = grf_load_dword(&buf);

   622 				break;

   648 			break;

   623 

   649 

   624 			case 0x17: // Callback mask

   650 		case 0x17: // Callback mask

   625 				ei->callbackmask = grf_load_byte(&buf);

   651 			FOR_EACH_OBJECT ei[i].callbackmask = grf_load_byte(&buf);

   626 				break;

   652 			break;

   627 

   653 

   628 			case 0x1A: // Refit cost

   654 		case 0x1A: // Refit cost

   629 				ei->refit_cost = grf_load_byte(&buf);

   655 			FOR_EACH_OBJECT ei[i].refit_cost = grf_load_byte(&buf);

   630 				break;

   656 			break;

   631 

   657 

   632 			case 0x1B: // Retire vehicle early

   658 		case 0x1B: // Retire vehicle early

   633 				ei->retire_early = grf_load_byte(&buf);

   659 			FOR_EACH_OBJECT ei[i].retire_early = grf_load_byte(&buf);

   634 				break;

   660 			break;

   635 

   661 

   636 			case 0x1C: // Miscellaneous flags

   662 		case 0x1C: // Miscellaneous flags

   637 				ei->misc_flags = grf_load_byte(&buf);

   663 			FOR_EACH_OBJECT {

   638 				_loaded_newgrf_features.has_2CC |= HASBIT(ei->misc_flags, EF_USES_2CC);

   664 				ei[i].misc_flags = grf_load_byte(&buf);

   639 				break;

   665 				_loaded_newgrf_features.has_2CC |= HASBIT(ei[i].misc_flags, EF_USES_2CC);

   640 

   666 			}

   641 			case 0x1D: // Cargo classes allowed

   667 			break;

   642 				cargo_allowed[ROAD_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   668 

   643 				break;

   669 		case 0x1D: // Cargo classes allowed

   644 

   670 			FOR_EACH_OBJECT cargo_allowed[ROAD_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   645 			case 0x1E: // Cargo classes disallowed

   671 			break;

   646 				cargo_disallowed[ROAD_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   672 

   647 				break;

   673 		case 0x1E: // Cargo classes disallowed

   648 

   674 			FOR_EACH_OBJECT cargo_disallowed[ROAD_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   649 			case 0x1F: // Long format introduction date (days since year 0)

   675 			break;

   650 				ei->base_intro = grf_load_dword(&buf);

   676 

   651 				break;

   677 		case 0x1F: // Long format introduction date (days since year 0)

   652 

   678 			FOR_EACH_OBJECT ei[i].base_intro = grf_load_dword(&buf);

   653 			case 0x18: // Tractive effort

   679 			break;

   654 			case 0x19: // Air drag

   680 

   655 				/* @todo */

   681 		case 0x18: // Tractive effort

   656 				grf_load_byte(&buf);

   682 		case 0x19: // Air drag

   657 				ret = true;

   683 			/* @todo */

   658 				break;

   684 			FOR_EACH_OBJECT grf_load_byte(&buf);

   659 

   685 			ret = true;

   660 			default:

   686 			break;

   661 				ret = true;

   687 

   662 				break;

   688 		default:

   663 		}

   689 			ret = true;

   690 			break;

   705 	//printf("e %x prop %x?\n", engine, prop);

   675 	for (int i = 0; i < numinfo; i++) {

   706 	switch (prop) {

   676 		EngineInfo *ei       = &_engine_info[SHIP_ENGINES_INDEX + engine + i];

   707 		case 0x08: // Sprite ID

   677 		ShipVehicleInfo *svi = &_ship_vehicle_info[engine + i];

   708 			FOR_EACH_OBJECT {

   678 

   679 		switch (prop) {

   680 			case 0x08: { // Sprite ID

   716 				svi[i].image_index = spriteid;

   688 				svi->image_index = spriteid;

   717 			}

   689 			} break;

   718 			break;

   690 

   719 

   691 			case 0x09: // Refittable

   720 		case 0x09: // Refittable

   692 				svi->refittable = (grf_load_byte(&buf) != 0);

   721 			FOR_EACH_OBJECT svi[i].refittable = (grf_load_byte(&buf) != 0);

   693 				break;

   722 			break;

   694 

   723 

   695 			case 0x0A: // Cost factor

   724 		case 0x0A: // Cost factor

   696 				svi->base_cost = grf_load_byte(&buf); // ?? is it base_cost?

   725 			FOR_EACH_OBJECT svi[i].base_cost = grf_load_byte(&buf); // ?? is it base_cost?

   697 				break;

   726 			break;

   698 

   727 

   699 			case 0x0B: // Speed (1 unit is 0.5 kmh)

   728 		case 0x0B: // Speed (1 unit is 0.5 kmh)

   700 				svi->max_speed = grf_load_byte(&buf);

   729 			FOR_EACH_OBJECT svi[i].max_speed = grf_load_byte(&buf);

   701 				break;

   730 			break;

   702 

   731 

   703 			case 0x0C: { // Cargo type

   732 		case 0x0C: // Cargo type

   733 			FOR_EACH_OBJECT {

   737 					svi[i].cargo_type = cargo;

   707 					svi->cargo_type = cargo;

   739 					svi[i].cargo_type = CT_INVALID;

   709 					svi->cargo_type = CT_INVALID;

   742 			}

   712 			} break;

   743 			break;

   713 

   744 

   714 			case 0x0D: // Cargo capacity

   745 		case 0x0D: // Cargo capacity

   715 				svi->capacity = grf_load_word(&buf);

   746 			FOR_EACH_OBJECT svi[i].capacity = grf_load_word(&buf);

   716 				break;

   747 			break;

   717 

   748 

   718 			case 0x0F: // Running cost factor

   749 		case 0x0F: // Running cost factor

   719 				svi->running_cost = grf_load_byte(&buf);

   750 			FOR_EACH_OBJECT svi[i].running_cost = grf_load_byte(&buf);

   720 				break;

   751 			break;

   721 

   752 

   722 			case 0x10: // SFX

   753 		case 0x10: // SFX

   723 				svi->sfx = (SoundFx)grf_load_byte(&buf);

   754 			FOR_EACH_OBJECT svi[i].sfx = (SoundFx)grf_load_byte(&buf);

   724 				break;

   755 			break;

   725 

   756 

   726 			case 0x11: // Cargos available for refitting

   757 		case 0x11: // Cargos available for refitting

   727 				ei->refit_mask = grf_load_dword(&buf);

   758 			FOR_EACH_OBJECT ei[i].refit_mask = grf_load_dword(&buf);

   728 				break;

   759 			break;

   729 

   760 

   730 			case 0x12: // Callback mask

   761 		case 0x12: // Callback mask

   731 				ei->callbackmask = grf_load_byte(&buf);

   762 			FOR_EACH_OBJECT ei[i].callbackmask = grf_load_byte(&buf);

   732 				break;

   763 			break;

   733 

   764 

   734 			case 0x13: // Refit cost

   765 		case 0x13: // Refit cost

   735 				ei->refit_cost = grf_load_byte(&buf);

   766 			FOR_EACH_OBJECT ei[i].refit_cost = grf_load_byte(&buf);

   736 				break;

   767 			break;

   737 

   768 

   738 			case 0x16: // Retire vehicle early

   769 		case 0x16: // Retire vehicle early

   739 				ei->retire_early = grf_load_byte(&buf);

   770 			FOR_EACH_OBJECT ei[i].retire_early = grf_load_byte(&buf);

   740 				break;

   771 			break;

   741 

   772 

   742 			case 0x17: // Miscellaneous flags

   773 		case 0x17: // Miscellaneous flags

   743 				ei->misc_flags = grf_load_byte(&buf);

   774 			FOR_EACH_OBJECT {

   744 				_loaded_newgrf_features.has_2CC |= HASBIT(ei->misc_flags, EF_USES_2CC);

   775 				ei[i].misc_flags = grf_load_byte(&buf);

   745 				break;

   776 				_loaded_newgrf_features.has_2CC |= HASBIT(ei[i].misc_flags, EF_USES_2CC);

   746 

   777 			}

   747 			case 0x18: // Cargo classes allowed

   778 			break;

   748 				cargo_allowed[SHIP_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   779 

   749 				break;

   780 		case 0x18: // Cargo classes allowed

   750 

   781 			FOR_EACH_OBJECT cargo_allowed[SHIP_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   751 			case 0x19: // Cargo classes disallowed

   782 			break;

   752 				cargo_disallowed[SHIP_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   783 

   753 				break;

   784 		case 0x19: // Cargo classes disallowed

   754 

   785 			FOR_EACH_OBJECT cargo_disallowed[SHIP_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   755 			case 0x1A: // Long format introduction date (days since year 0)

   786 			break;

   756 				ei->base_intro = grf_load_dword(&buf);

   787 

   757 				break;

   788 		case 0x1A: // Long format introduction date (days since year 0)

   758 

   789 			FOR_EACH_OBJECT ei[i].base_intro = grf_load_dword(&buf);

   759 			case 0x14: // Ocean speed fraction

   790 			break;

   760 			case 0x15: // Canal speed fraction

   791 

   761 				/* @todo */

   792 		case 0x14: // Ocean speed fraction

   762 				grf_load_byte(&buf);

   793 		case 0x15: // Canal speed fraction

   763 				ret = true;

   794 			/* @todo */

   764 				break;

   795 			FOR_EACH_OBJECT grf_load_byte(&buf);

   765 

   796 			ret = true;

   766 			default:

   797 			break;

   767 				ret = true;

   798 

   768 				break;

   799 		default:

   769 		}

   800 			ret = true;

   801 			break;

   816 	//printf("e %x prop %x?\n", engine, prop);

   781 	for (int i = 0; i < numinfo; i++) {

   817 	switch (prop) {

   782 		EngineInfo *ei           = &_engine_info[AIRCRAFT_ENGINES_INDEX + engine + i];

   818 		case 0x08: // Sprite ID

   783 		AircraftVehicleInfo *avi = &_aircraft_vehicle_info[engine + i];

   819 			FOR_EACH_OBJECT {

   784 

   785 		switch (prop) {

   786 			case 0x08: { // Sprite ID

   827 				avi[i].image_index = spriteid;

   794 				avi->image_index = spriteid;

   828 			}

   795 			} break;

   829 			break;

   796 

   830 

   797 			case 0x09: // Helicopter

   831 		case 0x09: // Helicopter

   832 			FOR_EACH_OBJECT {

   834 					avi[i].subtype = AIR_HELI;

   799 					avi->subtype = AIR_HELI;

   836 					SB(avi[i].subtype, 0, 1, 1); // AIR_CTOL

   801 					SB(avi->subtype, 0, 1, 1); // AIR_CTOL

   837 				}

   802 				}

   838 			}

   803 				break;

   839 			break;

   804 

   840 

   805 			case 0x0A: // Large

   841 		case 0x0A: // Large

   806 				SB(avi->subtype, 1, 1, (grf_load_byte(&buf) != 0 ? 1 : 0)); // AIR_FAST

   842 			FOR_EACH_OBJECT SB(avi[i].subtype, 1, 1, (grf_load_byte(&buf) != 0 ? 1 : 0)); // AIR_FAST

   807 				break;

   843 			break;

   808 

   844 

   809 			case 0x0B: // Cost factor

   845 		case 0x0B: // Cost factor

   810 				avi->base_cost = grf_load_byte(&buf); // ?? is it base_cost?

   846 			FOR_EACH_OBJECT avi[i].base_cost = grf_load_byte(&buf); // ?? is it base_cost?

   811 				break;

   847 			break;

   812 

   848 

   813 			case 0x0C: // Speed (1 unit is 8 mph, we translate to 1 unit is 1 km/h)

   849 		case 0x0C: // Speed (1 unit is 8 mph, we translate to 1 unit is 1 km/h)

   814 				avi->max_speed = (grf_load_byte(&buf) * 129) / 10;

   850 			FOR_EACH_OBJECT avi[i].max_speed = (grf_load_byte(&buf) * 129) / 10;

   815 				break;

   851 			break;

   816 

   852 

   817 			case 0x0D: // Acceleration

   853 		case 0x0D: // Acceleration

   818 				avi->acceleration = (grf_load_byte(&buf) * 129) / 10;

   854 			FOR_EACH_OBJECT avi[i].acceleration = (grf_load_byte(&buf) * 129) / 10;

   819 				break;

   855 			break;

   820 

   856 

   821 			case 0x0E: // Running cost factor

   857 		case 0x0E: // Running cost factor

   822 				avi->running_cost = grf_load_byte(&buf);

   858 			FOR_EACH_OBJECT avi[i].running_cost = grf_load_byte(&buf);

   823 				break;

   859 			break;

   824 

   860 

   825 			case 0x0F: // Passenger capacity

   861 		case 0x0F: // Passenger capacity

   826 				avi->passenger_capacity = grf_load_word(&buf);

   862 			FOR_EACH_OBJECT avi[i].passenger_capacity = grf_load_word(&buf);

   827 				break;

   863 			break;

   828 

   864 

   829 			case 0x11: // Mail capacity

   865 		case 0x11: // Mail capacity

   830 				avi->mail_capacity = grf_load_byte(&buf);

   866 			FOR_EACH_OBJECT avi[i].mail_capacity = grf_load_byte(&buf);

   831 				break;

   867 			break;

   832 

   868 

   833 			case 0x12: // SFX

   869 		case 0x12: // SFX

   834 				avi->sfx = (SoundFx)grf_load_byte(&buf);

   870 			FOR_EACH_OBJECT avi[i].sfx = (SoundFx)grf_load_byte(&buf);

   835 				break;

   871 			break;

   836 

   872 

   837 			case 0x13: // Cargos available for refitting

   873 		case 0x13: // Cargos available for refitting

   838 				ei->refit_mask = grf_load_dword(&buf);

   874 			FOR_EACH_OBJECT ei[i].refit_mask = grf_load_dword(&buf);

   839 				break;

   875 			break;

   840 

   876 

   841 			case 0x14: // Callback mask

   877 		case 0x14: // Callback mask

   842 				ei->callbackmask = grf_load_byte(&buf);

   878 			FOR_EACH_OBJECT ei[i].callbackmask = grf_load_byte(&buf);

   843 				break;

   879 			break;

   844 

   880 

   845 			case 0x15: // Refit cost

   881 		case 0x15: // Refit cost

   846 				ei->refit_cost = grf_load_byte(&buf);

   882 			FOR_EACH_OBJECT ei[i].refit_cost = grf_load_byte(&buf);

   847 				break;

   883 			break;

   848 

   884 

   849 			case 0x16: // Retire vehicle early

   885 		case 0x16: // Retire vehicle early

   850 				ei->retire_early = grf_load_byte(&buf);

   886 			FOR_EACH_OBJECT ei[i].retire_early = grf_load_byte(&buf);

   851 				break;

   887 			break;

   852 

   888 

   853 			case 0x17: // Miscellaneous flags

   889 		case 0x17: // Miscellaneous flags

   854 				ei->misc_flags = grf_load_byte(&buf);

   890 			FOR_EACH_OBJECT {

   855 				_loaded_newgrf_features.has_2CC |= HASBIT(ei->misc_flags, EF_USES_2CC);

   891 				ei[i].misc_flags = grf_load_byte(&buf);

   856 				break;

   892 				_loaded_newgrf_features.has_2CC |= HASBIT(ei[i].misc_flags, EF_USES_2CC);

   857 

   893 			}

   858 			case 0x18: // Cargo classes allowed

   894 			break;

   859 				cargo_allowed[AIRCRAFT_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   895 

   860 				break;

   896 		case 0x18: // Cargo classes allowed

   861 

   897 			FOR_EACH_OBJECT cargo_allowed[AIRCRAFT_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   862 			case 0x19: // Cargo classes disallowed

   898 			break;

   863 				cargo_disallowed[AIRCRAFT_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   899 

   864 				break;

   900 		case 0x19: // Cargo classes disallowed

   865 

   901 			FOR_EACH_OBJECT cargo_disallowed[AIRCRAFT_ENGINES_INDEX + engine + i] = grf_load_word(&buf);

   866 			case 0x1A: // Long format introduction date (days since year 0)

   902 			break;

   867 				ei->base_intro = grf_load_dword(&buf);

   903 

   868 				break;

   904 		case 0x1A: // Long format introduction date (days since year 0)

   869 

   905 			FOR_EACH_OBJECT ei[i].base_intro = grf_load_dword(&buf);

   870 			default:

   906 			break;

   871 				ret = true;

   907 

   872 				break;

   908 		default:

   873 		}

   909 			ret = true;

   910 			break;

   932 	statspec = &_cur_grffile->stations[stid];

   893 	for (int i = 0; i < numinfo; i++) {

   933 

   894 		StationSpec *statspec = _cur_grffile->stations[stid + i];

   934 	if (prop != 0x08) {

   895 

   935 		/* Check that all stations we are modifying are defined. */

   896 		/* Check that the station we are modifying is defined. */

   936 		FOR_EACH_OBJECT {

   897 		if (statspec == NULL && prop != 0x08) {

   937 			if (statspec[i] == NULL) {

   898 			grfmsg(2, "StationChangeInfo: Attempt to modify undefined station %u, ignoring", stid + i);

   938 				grfmsg(2, "StationChangeInfo: Attempt to modify undefined station %u, ignoring", stid + i);

   899 			continue;

   939 				return false;

   900 		}

   940 			}

   901 

   941 		}

   902 		switch (prop) {

   942 	}

   903 			case 0x08: { // Class ID

   943 

   904 				StationSpec **spec = &_cur_grffile->stations[stid + i];

   944 	switch (prop) {

   905 

   945 		case 0x08: // Class ID

   946 			FOR_EACH_OBJECT {

   948 				if (statspec[i] == NULL) statspec[i] = CallocT<StationSpec>(1);

   907 				if (*spec == NULL) *spec = CallocT<StationSpec>(1);

   952 				statspec[i]->sclass = AllocateStationClass(BSWAP32(classid));

   911 				(*spec)->sclass = AllocateStationClass(BSWAP32(classid));

   953 			}

   912 			} break;

   954 			break;

   913 

   955 

   914 			case 0x09: // Define sprite layout

   956 		case 0x09: // Define sprite layout

   957 			FOR_EACH_OBJECT {

   958 				StationSpec *statspec = _cur_grffile->stations[stid + i];

   959 

  1010 			}

   965 				break;

  1011 			break;

   966 

  1012 

   967 			case 0x0A: { // Copy sprite layout

  1013 		case 0x0A: // Copy sprite layout

  1014 			FOR_EACH_OBJECT {

  1015 				StationSpec *statspec = _cur_grffile->stations[stid + i];

  1022 			}

   974 			} break;

  1023 			break;

   975 

  1024 

   976 			case 0x0B: // Callback mask

  1025 		case 0x0B: // Callback mask

   977 				statspec->callbackmask = grf_load_byte(&buf);

  1026 			FOR_EACH_OBJECT statspec[i]->callbackmask = grf_load_byte(&buf);

   978 				break;

  1027 			break;

   979 

  1028 

   980 			case 0x0C: // Disallowed number of platforms

  1029 		case 0x0C: // Disallowed number of platforms

   981 				statspec->disallowed_platforms = grf_load_byte(&buf);

  1030 			FOR_EACH_OBJECT statspec[i]->disallowed_platforms = grf_load_byte(&buf);

   982 				break;

  1031 			break;

   983 

  1032 

   984 			case 0x0D: // Disallowed platform lengths

  1033 		case 0x0D: // Disallowed platform lengths

   985 				statspec->disallowed_lengths = grf_load_byte(&buf);

  1034 			FOR_EACH_OBJECT statspec[i]->disallowed_lengths = grf_load_byte(&buf);

   986 				break;

  1035 			break;

   987 

  1036 

   988 			case 0x0E: // Define custom layout

  1037 		case 0x0E: // Define custom layout

  1038 			FOR_EACH_OBJECT {

  1039 				StationSpec *statspec = _cur_grffile->stations[stid + i];

  1040 

  1087 			}

  1035 				break;

  1088 			break;

  1036 

  1089 

  1037 			case 0x0F: { // Copy custom layout

  1090 		case 0x0F: // Copy custom layout

  1091 			FOR_EACH_OBJECT {

  1092 				StationSpec *statspec = _cur_grffile->stations[stid + i];

  1100 			}

  1045 			} break;

  1101 			break;

  1046 

  1102 

  1047 			case 0x10: // Little/lots cargo threshold

  1103 		case 0x10: // Little/lots cargo threshold

  1048 				statspec->cargo_threshold = grf_load_word(&buf);

  1104 			FOR_EACH_OBJECT statspec[i]->cargo_threshold = grf_load_word(&buf);

  1049 				break;

  1105 			break;

  1050 

  1106 

  1051 			case 0x11: // Pylon placement

  1107 		case 0x11: // Pylon placement

  1052 				statspec->pylons = grf_load_byte(&buf);

  1108 			FOR_EACH_OBJECT statspec[i]->pylons = grf_load_byte(&buf);

  1053 				break;

  1109 			break;

  1054 

  1110 

  1055 			case 0x12: // Cargo types for random triggers

  1111 		case 0x12: // Cargo types for random triggers

  1056 				statspec->cargo_triggers = grf_load_dword(&buf);

  1112 			FOR_EACH_OBJECT statspec[i]->cargo_triggers = grf_load_dword(&buf);

  1057 				break;

  1113 			break;

  1058 

  1114 

  1059 			case 0x13: // General flags

  1115 		case 0x13: // General flags

  1060 				statspec->flags = grf_load_byte(&buf);

  1116 			FOR_EACH_OBJECT statspec[i]->flags = grf_load_byte(&buf);

  1061 				break;

  1117 			break;

  1062 

  1118 

  1063 			case 0x14: // Overhead wire placement

  1119 		case 0x14: // Overhead wire placement

  1064 				statspec->wires = grf_load_byte(&buf);

  1120 			FOR_EACH_OBJECT statspec[i]->wires = grf_load_byte(&buf);

  1065 				break;

  1121 			break;

  1066 

  1122 

  1067 			case 0x15: // Blocked tiles

  1123 		case 0x15: // Blocked tiles

  1068 				statspec->blocked = grf_load_byte(&buf);

  1124 			FOR_EACH_OBJECT statspec[i]->blocked = grf_load_byte(&buf);

  1069 				break;

  1125 			break;

  1070 

  1126 

  1071 			case 0x16: // @todo Animation info

  1127 		case 0x16: // @todo Animation info

  1072 				grf_load_word(&buf);

  1128 			FOR_EACH_OBJECT grf_load_word(&buf);

  1073 				ret = true;

  1129 			ret = true;

  1074 				break;

  1130 			break;

  1075 

  1131 

  1076 			case 0x17: // @todo Animation speed

  1132 		case 0x17: // @todo Animation speed

  1077 				grf_load_byte(&buf);

  1133 			FOR_EACH_OBJECT grf_load_byte(&buf);

  1078 				ret = true;

  1134 			ret = true;

  1079 				break;

  1135 			break;

  1080 

  1136 

  1081 			case 0x18: // @todo Animation triggers

  1137 		case 0x18: // @todo Animation triggers

  1082 				grf_load_word(&buf);

  1138 			FOR_EACH_OBJECT grf_load_word(&buf);

  1083 				ret = true;

  1139 			ret = true;

  1084 				break;

  1140 			break;

  1085 

  1141 

  1086 			default:

  1142 		default:

  1087 				ret = true;

  1143 			ret = true;

  1088 				break;

  1144 			break;

  1089 		}

  1157 	switch (prop) {

  1101 	if (brid + numinfo > MAX_BRIDGES) {

  1158 		case 0x08: // Year of availability

  1102 		grfmsg(1, "BridgeChangeInfo: Bridge %u is invalid, max %u, ignoring", brid + numinfo, MAX_BRIDGES);

  1159 			FOR_EACH_OBJECT _bridge[brid + i].avail_year = ORIGINAL_BASE_YEAR + grf_load_byte(&buf);

  1103 		return false;

  1160 			break;

  1104 	}

  1161 

  1105 

  1162 		case 0x09: // Minimum length

  1106 	for (int i = 0; i < numinfo; i++) {

  1163 			FOR_EACH_OBJECT _bridge[brid + i].min_length = grf_load_byte(&buf);

  1107 		Bridge *bridge = &_bridge[brid + i];

  1164 			break;

  1108 

  1165 

  1109 		switch (prop) {

  1166 		case 0x0A: // Maximum length

  1110 			case 0x08: // Year of availability

  1167 			FOR_EACH_OBJECT _bridge[brid + i].max_length = grf_load_byte(&buf);

  1111 				bridge->avail_year = ORIGINAL_BASE_YEAR + grf_load_byte(&buf);

  1168 			break;

  1112 				break;

  1169 

  1113 

  1170 		case 0x0B: // Cost factor

  1114 			case 0x09: // Minimum length

  1171 			FOR_EACH_OBJECT _bridge[brid + i].price = grf_load_byte(&buf);

  1115 				bridge->min_length = grf_load_byte(&buf);

  1172 			break;

  1116 				break;

  1173 

  1117 

  1174 		case 0x0C: // Maximum speed

  1118 			case 0x0A: // Maximum length

  1175 			FOR_EACH_OBJECT _bridge[brid + i].speed = grf_load_word(&buf);

  1119 				bridge->max_length = grf_load_byte(&buf);

  1176 			break;

  1120 				break;

  1177 

  1121 

  1178 		case 0x0D: // Bridge sprite tables

  1122 			case 0x0B: // Cost factor

  1179 			FOR_EACH_OBJECT {

  1123 				bridge->price = grf_load_byte(&buf);

  1180 				Bridge *bridge = &_bridge[brid + i];

  1124 				break;

  1125 

  1126 			case 0x0C: // Maximum speed

  1127 				bridge->speed = grf_load_word(&buf);

  1128 				break;

  1129 

  1130 			case 0x0D: { // Bridge sprite tables

  1215 			}

  1165 			} break;

  1216 			break;

  1166 

  1217 

  1167 			case 0x0E: // Flags; bit 0 - disable far pillars

  1218 		case 0x0E: // Flags; bit 0 - disable far pillars

  1168 				bridge->flags = grf_load_byte(&buf);

  1219 			FOR_EACH_OBJECT _bridge[brid + i].flags = grf_load_byte(&buf);

  1169 				break;

  1220 			break;

  1170 

  1221 

  1171 			case 0x0F: // Long format year of availability (year since year 0)

  1222 		case 0x0F: // Long format year of availability (year since year 0)

  1172 				bridge->avail_year = clamp(grf_load_dword(&buf), MIN_YEAR, MAX_YEAR);

  1223 			FOR_EACH_OBJECT _bridge[brid + i].avail_year = clamp(grf_load_dword(&buf), MIN_YEAR, MAX_YEAR);

  1173 				break;

  1224 			break;

  1174 

  1225 

  1175 			default:

  1226 		default:

  1176 				ret = true;

  1227 			ret = true;

  1177 				break;

  1178 		}

  1254 	housespec = &_cur_grffile->housespec[hid];

  1203 	for (int i = 0; i < numinfo; i++) {

  1255 

  1204 		HouseSpec *housespec = _cur_grffile->housespec[hid + i];

  1256 	if (prop != 0x08) {

  1205 

  1257 		/* Check that all the houses being modified have been defined. */

  1206 		if (prop != 0x08 && housespec == NULL) {

  1258 		FOR_EACH_OBJECT {

  1207 			grfmsg(2, "TownHouseChangeInfo: Attempt to modify undefined house %u. Ignoring.", hid + i);

  1259 			if (housespec[i] == NULL) {

  1208 			continue;

  1260 				grfmsg(2, "TownHouseChangeInfo: Attempt to modify undefined house %u. Ignoring.", hid + i);

  1209 		}

  1261 				return false;

  1210 

  1262 			}

  1211 		switch (prop) {

  1263 		}

  1212 			case 0x08: { // Substitute building type, and definition of a new house

  1264 	}

  1213 				HouseSpec **house = &_cur_grffile->housespec[hid + i];

  1265 

  1266 	switch (prop) {

  1267 		case 0x08: // Substitute building type, and definition of a new house

  1268 			FOR_EACH_OBJECT {

  1283 				if (housespec[i] == NULL) housespec[i] = CallocT<HouseSpec>(1);

  1228 				if (*house == NULL) *house = CallocT<HouseSpec>(1);

  1284 

  1229 

  1285 				memcpy(housespec[i], &_house_specs[subs_id], sizeof(_house_specs[subs_id]));

  1230 				housespec = *house;

  1286 

  1231 

  1287 				housespec[i]->enabled = true;

  1232 				memcpy(housespec, &_house_specs[subs_id], sizeof(_house_specs[subs_id]));

  1288 				housespec[i]->local_id = hid + i;

  1233 

  1289 				housespec[i]->substitute_id = subs_id;

  1234 				housespec->enabled = true;

  1290 				housespec[i]->grffile = _cur_grffile;

  1235 				housespec->local_id = hid + i;

  1291 				housespec[i]->random_colour[0] = 0x04;  // those 4 random colours are the base colour

  1236 				housespec->substitute_id = subs_id;

  1292 				housespec[i]->random_colour[1] = 0x08;  // for all new houses

  1237 				housespec->grffile = _cur_grffile;

  1293 				housespec[i]->random_colour[2] = 0x0C;  // they stand for red, blue, orange and green

  1238 				housespec->random_colour[0] = 0x04;  // those 4 random colours are the base colour

  1294 				housespec[i]->random_colour[3] = 0x06;

  1239 				housespec->random_colour[1] = 0x08;  // for all new houses

  1240 				housespec->random_colour[2] = 0x0C;  // they stand for red, blue, orange and green

  1241 				housespec->random_colour[3] = 0x06;

  1299 				if (housespec[i]->min_date < 1930) housespec[i]->min_date = 1930;

  1246 				if (housespec->min_date < 1930) housespec->min_date = 1930;

  1300 			}

  1247 

  1301 			_loaded_newgrf_features.has_newhouses = true;

  1248 				_loaded_newgrf_features.has_newhouses = true;

  1302 			break;

  1249 			} break;

  1303 

  1250 

  1304 		case 0x09: // Building flags

  1251 			case 0x09: // Building flags

  1305 			FOR_EACH_OBJECT {

  1252 				housespec->building_flags = (BuildingFlags)grf_load_byte(&buf);

  1306 				byte state = grf_load_byte(&buf);

  1253 				break;

  1307 				housespec[i]->building_flags = (BuildingFlags)state;

  1254 

  1308 			}

  1255 			case 0x0A: { // Availability years

  1309 			break;

  1310 

  1311 		case 0x0A: // Availability years

  1312 			FOR_EACH_OBJECT {

  1314 				housespec[i]->min_date = GB(years, 0, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 0, 8);

  1257 				housespec->min_date = GB(years, 0, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 0, 8);

  1315 				housespec[i]->max_date = GB(years, 8, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 8, 8);

  1258 				housespec->max_date = GB(years, 8, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 8, 8);

  1316 			}

  1259 			} break;

  1317 			break;

  1260 

  1318 

  1261 			case 0x0B: // Population

  1319 		case 0x0B: // Population

  1262 				housespec->population = grf_load_byte(&buf);

  1320 			FOR_EACH_OBJECT housespec[i]->population = grf_load_byte(&buf);

  1263 				break;

  1321 			break;

  1264 

  1322 

  1265 			case 0x0C: // Mail generation multiplier

  1323 		case 0x0C: // Mail generation multiplier

  1266 				housespec->mail_generation = grf_load_byte(&buf);

  1324 			FOR_EACH_OBJECT housespec[i]->mail_generation = grf_load_byte(&buf);

  1267 				break;

  1325 			break;

  1268 

  1326 

  1269 			case 0x0D: // Passenger acceptance

  1327 		case 0x0D: // Passenger acceptance

  1270 			case 0x0E: // Mail acceptance

  1328 		case 0x0E: // Mail acceptance

  1271 				housespec->cargo_acceptance[prop - 0x0D] = grf_load_byte(&buf);

  1329 			FOR_EACH_OBJECT housespec[i]->cargo_acceptance[prop - 0x0D] = grf_load_byte(&buf);

  1272 				break;

  1330 			break;

  1273 

  1331 		case 0x0F: // Goods/candy, food/fizzy drinks acceptance

  1274 			case 0x0F: { // Goods/candy, food/fizzy drinks acceptance

  1332 			FOR_EACH_OBJECT {

  1337 				housespec[i]->accepts_cargo[2] = (goods >= 0) ? ((_opt.landscape == LT_TOYLAND) ? CT_CANDY : CT_GOODS) :

  1279 				housespec->accepts_cargo[2] = (goods >= 0) ? ((_opt.landscape == LT_TOYLAND) ? CT_CANDY : CT_GOODS) :

  1340 				housespec[i]->cargo_acceptance[2] = abs(goods); // but we do need positive value here

  1282 				housespec->cargo_acceptance[2] = abs(goods); // but we do need positive value here

  1341 			}

  1283 			} break;

  1342 			break;

  1284 

  1343 

  1285 			case 0x10: // Local authority rating decrease on removal

  1344 		case 0x10: // Local authority rating decrease on removal

  1286 				housespec->remove_rating_decrease = grf_load_word(&buf);

  1345 			FOR_EACH_OBJECT housespec[i]->remove_rating_decrease = grf_load_word(&buf);

  1287 				break;

  1346 			break;

  1288 

  1347 

  1289 			case 0x11: // Removal cost multiplier

  1348 		case 0x11: // Removal cost multiplier

  1290 				housespec->removal_cost = grf_load_byte(&buf);

  1349 			FOR_EACH_OBJECT housespec[i]->removal_cost = grf_load_byte(&buf);

  1291 				break;

  1350 			break;

  1292 

  1351 

  1293 			case 0x12: // Building name ID

  1352 		case 0x12: // Building name ID

  1294 				housespec->building_name = MapGRFStringID(_cur_grffile->grfid, grf_load_word(&buf));

  1353 			FOR_EACH_OBJECT housespec[i]->building_name = MapGRFStringID(_cur_grffile->grfid, grf_load_word(&buf));

  1295 				break;

  1354 			break;

  1296 

  1355 

  1297 			case 0x13: // Building availability mask

  1356 		case 0x13: // Building availability mask

  1298 				housespec->building_availability = (HouseZones)grf_load_word(&buf);

  1357 			FOR_EACH_OBJECT {

  1299 				break;

  1358 				uint16 avail = grf_load_word(&buf);

  1300 

  1359 				housespec[i]->building_availability = (HouseZones)avail;

  1301 			case 0x14: // House callback flags

  1360 			}

  1302 				housespec->callback_mask = grf_load_byte(&buf);

  1361 			break;

  1303 				break;

  1362 

  1304 

  1363 		case 0x14: // House callback flags

  1305 			case 0x15: { // House override byte

  1364 			FOR_EACH_OBJECT housespec[i]->callback_mask = grf_load_byte(&buf);

  1365 			break;

  1366 

  1367 		case 0x15: // House override byte

  1368 			FOR_EACH_OBJECT {

  1374 					return false;

  1311 					continue;

  1378 			}

  1315 			} break;

  1379 			break;

  1316 

  1380 

  1317 			case 0x16: // Periodic refresh multiplier

  1381 		case 0x16: // Periodic refresh multiplier

  1318 				housespec->processing_time = grf_load_byte(&buf);

  1382 			FOR_EACH_OBJECT housespec[i]->processing_time = grf_load_byte(&buf);

  1319 				break;

  1383 			break;

  1320 

  1384 

  1321 			case 0x17: // Four random colours to use

  1385 		case 0x17: // Four random colours to use

  1322 				for (uint j = 0; j < 4; j++) housespec->random_colour[j] = grf_load_byte(&buf);

  1386 			FOR_EACH_OBJECT {

  1323 				break;

  1387 				uint j;

  1324 

  1388 				for (j = 0; j < 4; j++) housespec[i]->random_colour[j] = grf_load_byte(&buf);

  1325 			case 0x18: // Relative probability of appearing

  1389 			}

  1326 				housespec->probability = grf_load_byte(&buf);

  1390 			break;

  1327 				break;

  1391 

  1328 

  1392 		case 0x18: // Relative probability of appearing

  1329 			case 0x19: // Extra flags

  1393 			FOR_EACH_OBJECT housespec[i]->probability = grf_load_byte(&buf);

  1330 				housespec->extra_flags = (HouseExtraFlags)grf_load_byte(&buf);

  1394 			break;

  1331 				break;

  1395 

  1332 

  1396 		case 0x19: // Extra flags

  1333 			case 0x1A: // Animation frames

  1397 			FOR_EACH_OBJECT {

  1334 				housespec->animation_frames = grf_load_byte(&buf);

  1398 				byte flags = grf_load_byte(&buf);

  1335 				break;

  1399 				housespec[i]->extra_flags = (HouseExtraFlags)flags;

  1336 

  1400 			}

  1337 			case 0x1B: // Animation speed

  1401 			break;

  1338 				housespec->animation_speed = clamp(grf_load_byte(&buf), 2, 16);

  1402 

  1339 				break;

  1403 		case 0x1A: // Animation frames

  1340 

  1404 			FOR_EACH_OBJECT housespec[i]->animation_frames = grf_load_byte(&buf);

  1341 			case 0x1C: // Class of the building type

  1405 			break;

  1342 				housespec->class_id = AllocateHouseClassID(grf_load_byte(&buf), _cur_grffile->grfid);

  1406 

  1343 				break;

  1407 		case 0x1B: // Animation speed

  1344 

  1408 			FOR_EACH_OBJECT housespec[i]->animation_speed = clamp(grf_load_byte(&buf), 2, 16);

  1345 			case 0x1D: // Callback flags 2

  1409 			break;

  1346 				housespec->callback_mask |= (grf_load_byte(&buf) << 8);

  1410 

  1347 				break;

  1411 		case 0x1C: // Class of the building type

  1348 

  1412 			FOR_EACH_OBJECT housespec[i]->class_id = AllocateHouseClassID(grf_load_byte(&buf), _cur_grffile->grfid);

  1349 			case 0x1E: { // Accepted cargo types

  1413 			break;

  1414 

  1415 		case 0x1D: // Callback flags 2

  1416 			FOR_EACH_OBJECT housespec[i]->callback_mask |= (grf_load_byte(&buf) << 8);

  1417 			break;

  1418 

  1419 		case 0x1E: // Accepted cargo types

  1420 			FOR_EACH_OBJECT {

  1433 						housespec[i]->cargo_acceptance[j] = 0;

  1362 						housespec->cargo_acceptance[j] = 0;

  1435 						housespec[i]->accepts_cargo[j] = cargo;

  1364 						housespec->accepts_cargo[j] = cargo;

  1438 			}

  1367 			} break;

  1439 			break;

  1368 

  1440 

  1369 			case 0x1F: // Minimum life span

  1441 		case 0x1F: // Minimum life span

  1370 				housespec->minimum_life = grf_load_byte(&buf);

  1442 			FOR_EACH_OBJECT housespec[i]->minimum_life = grf_load_byte(&buf);

  1371 				break;

  1443 			break;

  1372 

  1444 

  1373 			default:

  1445 		default:

  1374 				ret = true;

  1446 			ret = true;

  1375 				break;

  1447 			break;

  1376 		}

  1460 	switch (prop) {

  1388 	for (int i = 0; i < numinfo; i++) {

  1461 		case 0x08: /* Cost base factor */

  1389 		switch (prop) {

  1462 			FOR_EACH_OBJECT {

  1390 			case 0x08: { /* Cost base factor */

  1471 			}

  1399 			} break;

  1472 			break;

  1400 

  1473 

  1401 			case 0x09: /* Cargo translation table */

  1474 		case 0x09: /* Cargo translation table */

  1402 				/* This is loaded during the initialisation stage, so just skip it here. */

  1475 			/* This is loaded during the initialisation stage, so just skip it here. */

  1403 				/* Each entry is 4 bytes. */

  1476 			/* Each entry is 4 bytes. */

  1404 				buf += 4;

  1477 			buf += numinfo * 4;

  1405 				break;

  1478 			break;

  1406 

  1479 

  1407 			case 0x0A: { // Currency display names

  1480 		case 0x0A: // Currency display names

  1481 			FOR_EACH_OBJECT {

  1488 			}

  1414 			} break;

  1489 			break;

  1415 

  1490 

  1416 			case 0x0B: { // Currency multipliers

  1491 		case 0x0B: // Currency multipliers

  1492 			FOR_EACH_OBJECT {

  1504 			}

  1428 			} break;

  1505 			break;

  1429 

  1506 

  1430 			case 0x0C: { // Currency options

  1507 		case 0x0C: // Currency options

  1508 			FOR_EACH_OBJECT {

  1520 			}

  1442 			} break;

  1521 			break;

  1443