1 #include "stdafx.h"

     2 

     3 #include <stdarg.h>

     4 

     5 #include "ttd.h"

     6 #include "gfx.h"

     7 #include "fileio.h"

     8 #include "engine.h"

     9 #include "station.h"

    10 #include "sprite.h"

    11 

    12 /* TTDPatch extended GRF format codec

    13  * (c) Petr Baudis 2004 (GPL'd)

    14  * Changes by Florian octo Forster are (c) by the OpenTTD development team.

    15  *

    16  * Contains portions of documentation by TTDPatch team.

    17  * Thanks especially to Josef Drexler for the documentation as well as a lot

    18  * of help at #tycoon. Also thanks to Michael Blunck for is GRF files which

    19  * served as subject to the initial testing of this codec. */

    20 

    21 extern int _skip_sprites;

    22 extern int _replace_sprites_count[16];

    23 extern int _replace_sprites_offset[16];

    24 extern int _traininfo_vehicle_pitch;

    25 

    26 struct GRFFile {

    27 	char *filename;

    28 	uint32 grfid;

    29 	uint16 flags;

    30 	uint16 sprite_offset;

    31 	struct GRFFile *next;

    32 

    33 	/* A sprite group contains all sprites of a given vehicle (or multiple

    34 	 * vehicles) when carrying given cargo. It consists of several sprite

    35 	 * sets.  Group ids are refered as "cargo id"s by TTDPatch

    36 	 * documentation, contributing to the global confusion.

    37 	 *

    38 	 * A sprite set contains all sprites of a given vehicle carrying given

    39 	 * cargo at a given *stage* - that is usually its load stage. Ie. you

    40 	 * can have a spriteset for an empty wagon, wagon full of coal,

    41 	 * half-filled wagon etc.  Each spriteset contains eight sprites (one

    42 	 * per direction) or four sprites if the vehicle is symmetric. */

    43 

    44 	int spriteset_start;

    45 	int spriteset_numsets;

    46 	int spriteset_numents;

    47 	int spriteset_feature;

    48 

    49 	int spritegroups_count;

    50 	struct SpriteGroup *spritegroups;

    51 

    52 	struct StationSpec stations[256];

    53 };

    54 

    55 static struct GRFFile *_cur_grffile, *_first_grffile;

    56 static int _cur_spriteid;

    57 static int _cur_stage;

    58 extern int _custom_sprites_base;

    59 

    60 static int32 _paramlist[0x7f];

    61 static int _param_max;

    62 

    63 /* 32 * 8 = 256 flags. Apparently TTDPatch uses this many.. */

    64 static uint32 _ttdpatch_flags[8];

    65 

    66 

    67 enum grfspec_feature {

    68 	GSF_TRAIN,

    69 	GSF_ROAD,

    70 	GSF_SHIP,

    71 	GSF_AIRCRAFT,

    72 	GSF_STATION,

    73 	GSF_BRIDGE,

    74 	GSF_TOWNHOUSE,

    75 };

    76 

    77 

    78 typedef void (*SpecialSpriteHandler)(byte *buf, int len);

    79 

    80 static const int _vehcounts[4] = {

    81 	/* GSF_TRAIN */    NUM_TRAIN_ENGINES,

    82 	/* GSF_ROAD */     NUM_ROAD_ENGINES,

    83 	/* GSF_SHIP */     NUM_SHIP_ENGINES,

    84 	/* GSF_AIRCRAFT */ NUM_AIRCRAFT_ENGINES

    85 };

    86 

    87 static const int _vehshifts[4] = {

    88 	/* GSF_TRAIN */    0,

    89 	/* GSF_ROAD */     ROAD_ENGINES_INDEX,

    90 	/* GSF_SHIP */     SHIP_ENGINES_INDEX,

    91 	/* GSF_AIRCRAFT */ AIRCRAFT_ENGINES_INDEX,

    92 };

    93 

    94 

    95 /* Debugging messages policy:

    96  *

    97  * These should be the severities used for direct DEBUG() calls

    98  * (there is room for exceptions, but you have to have a good cause):

    99  *

   100  * 0..2 - dedicated to grfmsg()

   101  * 3

   102  * 4

   103  * 5

   104  * 6 - action handler entry reporting - one per action

   105  * 7 - basic action progress reporting - in loops, only single one allowed

   106  * 8 - more detailed progress reporting - less important stuff, in deep loops etc

   107  * 9 - extremely detailed progress reporting - detailed reports inside of deep loops and so

   108  */

   109 

   110 

   111 enum grfmsg_severity {

   112 	GMS_NOTICE,

   113 	GMS_WARN,

   114 	GMS_ERROR,

   115 	GMS_FATAL,

   116 };

   117 

   118 static void CDECL grfmsg(enum grfmsg_severity severity, const char *str, ...)

   119 {

   120 	static const char * const severitystr[4] = { "Notice", "Warning", "Error", "Fatal" };

   121 	int export_severity = 0;

   122 	char buf[1024];

   123 	va_list va;

   124 

   125 	va_start(va, str);

   126 	vsprintf(buf, str, va);

   127 	va_end(va);

   128 

   129 	export_severity = 2 - (severity == GMS_FATAL ? 2 : severity);

   130 	DEBUG(grf, export_severity) ("[%s][%s] %s", _cur_grffile->filename, severitystr[severity], buf);

   131 }

   132 

   133 

   134 #define check_length(real, wanted, where) \

   135 do { \

   136 	if (real < wanted) { \

   137 		grfmsg(GMS_ERROR, "%s: Invalid special sprite length %d (expected %d)!", where, real, wanted); \

   138 		return; \

   139 	} \

   140 } while (0)

   141 

   142 

   143 static byte INLINE grf_load_byte(byte **buf)

   144 {

   145 	return *(*buf)++;

   146 }

   147 

   148 static uint16 grf_load_word(byte **buf)

   149 {

   150 	uint16 val;

   151 	byte *p = *buf;

   152 	val = p[0];

   153 	val |= p[1] << 8;

   154 	*buf = p + 2;

   155 	return val;

   156 }

   157 

   158 static uint16 grf_load_dword(byte **buf)

   159 {

   160 	uint32 val;

   161 	byte *p = *buf;

   162 	val = p[0];

   163 	val |= p[1] << 8;

   164 	val |= p[2] << 16;

   165 	val |= p[3] << 24;

   166 	*buf = p + 4;

   167 	return val;

   168 }

   169 

   170 

   171 static struct GRFFile *GetFileByGRFID(uint32 grfid)

   172 {

   173 	struct GRFFile *file;

   174 

   175 	file = _first_grffile;

   176 	while ((file != NULL) && (file->grfid != grfid))

   177 		file = file->next;

   178 

   179 	return file;

   180 }

   181 

   182 static struct GRFFile *GetFileByFilename(const char *filename)

   183 {

   184 	struct GRFFile *file;

   185 

   186 	file = _first_grffile;

   187 	while ((file != NULL) && strcmp(file->filename, filename))

   188 		file = file->next;

   189 

   190 	return file;

   191 }

   192 

   193 

   194 typedef bool (*VCI_Handler)(uint engine, int numinfo, int prop, byte **buf, int len);

   195 

   196 #define FOR_EACH_OBJECT for (i = 0; i < numinfo; i++)

   197 

   198 static void dewagonize(int condition, int engine)

   199 {

   200 	EngineInfo *ei = &_engine_info[engine];

   201 	RailVehicleInfo *rvi = &_rail_vehicle_info[engine];

   202 

   203 	if (condition != 0) {

   204 		ei->unk2 &= ~0x80;

   205 		rvi->flags &= ~2;

   206 	} else {

   207 		ei->unk2 |= 0x80;

   208 		rvi->flags |= 2;

   209 	}

   210 }

   211 

   212 static bool RailVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)

   213 {

   214 	EngineInfo *ei = &_engine_info[engine];

   215 	RailVehicleInfo *rvi = &_rail_vehicle_info[engine];

   216 	byte *buf = *bufp;

   217 	int i;

   218 	bool ret = false;

   219 

   220 	switch (prop) {

   221 		case 0x05: {	/* Track type */

   222 			FOR_EACH_OBJECT {

   223 				uint8 tracktype = grf_load_byte(&buf);

   224 

   225 				ei[i].railtype_climates &= 0xf;

   226 				ei[i].railtype_climates |= tracktype << 4;

   227 			}

   228 		}	break;

   229 		case 0x08: {	/* AI passenger service */

   230 			/* TODO */

   231 			FOR_EACH_OBJECT {

   232 				grf_load_byte(&buf);

   233 			}

   234 			ret = true;

   235 		}	break;

   236 		case 0x09: {	/* Speed */

   237 			FOR_EACH_OBJECT {

   238 				uint16 speed = grf_load_word(&buf);

   239 

   240 				rvi[i].max_speed = speed;

   241 				dewagonize(speed, engine + i);

   242 			}

   243 		}	break;

   244 		case 0x0B: {	/* Power */

   245 			FOR_EACH_OBJECT {

   246 				uint16 power = grf_load_word(&buf);

   247 

   248 				rvi[i].power = power;

   249 				dewagonize(power, engine + i);

   250 			}

   251 		}	break;

   252 		case 0x0D: {	/* Running cost factor */

   253 			FOR_EACH_OBJECT {

   254 				uint8 runcostfact = grf_load_byte(&buf);

   255 

   256 				rvi[i].running_cost_base = runcostfact;

   257 				dewagonize(runcostfact, engine + i);

   258 			}

   259 		}	break;

   260 		case 0x0E: {	/* Running cost base */

   261 			FOR_EACH_OBJECT {

   262 				uint32 base = grf_load_dword(&buf);

   263 

   264 				switch (base) {

   265 				case 0x4C30:

   266 					rvi[i].engclass = 0;

   267 					break;

   268 				case 0x4C36:

   269 					rvi[i].engclass = 1;

   270 					break;

   271 				case 0x4C3C:

   272 					rvi[i].engclass = 2;

   273 					break;

   274 				}

   275 				dewagonize(base, engine + i);

   276 			}

   277 		}	break;

   278 		case 0x12: {	/* Sprite ID */

   279 			FOR_EACH_OBJECT {

   280 				uint8 spriteid = grf_load_byte(&buf);

   281 

   282 				if (spriteid == 0xFD && rvi[i].image_index != 0xFD)

   283 					_engine_original_sprites[engine + i] = rvi[i].image_index;

   284 				rvi[i].image_index = spriteid;

   285 			}

   286 		}	break;

   287 		case 0x13: {	/* Dual-headed */

   288 			FOR_EACH_OBJECT {

   289 				uint8 dual = grf_load_byte(&buf);

   290 

   291 				if (dual != 0) {

   292 					rvi[i].flags |= 1;

   293 				} else {

   294 					rvi[i].flags &= ~1;

   295 				}

   296 			}

   297 		}	break;

   298 		case 0x14: {	/* Cargo capacity */

   299 			FOR_EACH_OBJECT {

   300 				uint8 capacity = grf_load_byte(&buf);

   301 

   302 				rvi[i].capacity = capacity;

   303 			}

   304 		}	break;

   305 		case 0x15: {	/* Cargo type */

   306 			FOR_EACH_OBJECT {

   307 				uint8 ctype = grf_load_byte(&buf);

   308 

   309 				rvi[i].cargo_type = ctype;

   310 			}

   311 		}	break;

   312 		case 0x16: {	/* Weight */

   313 			FOR_EACH_OBJECT {

   314 				uint8 weight = grf_load_byte(&buf);

   315 

   316 				rvi[i].weight = weight;

   317 			}

   318 		}	break;

   319 		case 0x17: {	/* Cost factor */

   320 			FOR_EACH_OBJECT {

   321 				uint8 cfactor = grf_load_byte(&buf);

   322 

   323 				rvi[i].base_cost = cfactor;

   324 			}

   325 		}	break;

   326 		case 0x18: {	/* AI rank */

   327 			/* TODO: _railveh_score should be merged to _rail_vehicle_info. */

   328 			FOR_EACH_OBJECT {

   329 				grf_load_byte(&buf);

   330 			}

   331 			ret = true;

   332 		}	break;

   333 		case 0x19: { /* Engine traction type */

   334 			/* TODO: What do the individual numbers mean?

   335 			 * XXX: And in what base are they, in fact? --pasky */

   336 			FOR_EACH_OBJECT {

   337 				uint8 traction = grf_load_byte(&buf);

   338 				int engclass;

   339 

   340 				if (traction <= 0x07)

   341 					engclass = 0;

   342 				else if (traction <= 0x27)

   343 					engclass = 1;

   344 				else if (traction <= 0x31)

   345 					engclass = 2;

   346 				else

   347 					break;

   348 

   349 				rvi[i].engclass = engclass;

   350 			}

   351 		}	break;

   352 		case 0x1D: {	/* Refit cargo */

   353 			FOR_EACH_OBJECT {

   354 				uint32 refit_mask = grf_load_dword(&buf);

   355 

   356 				_engine_refit_masks[engine + i] = refit_mask;

   357 			}

   358 		}	break;

   359 

   360 		/* TODO */

   361 		/* Fall-through for unimplemented two bytes long properties. */

   362 		case 0x1B:	/* Powered wagons power bonus */

   363 			FOR_EACH_OBJECT {

   364 				grf_load_byte(&buf);

   365 			}

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

   367 		case 0x1A:	/* Sort order */

   368 		case 0x1C:	/* Refit cost */

   369 		case 0x1E:	/* Callback */

   370 		case 0x1F:	/* Tractive effort */

   371 		case 0x21:	/* Shorter tenders */

   372 		case 0x22:	/* Visual */

   373 		case 0x23: {/* Powered wagons weight bonus */

   374 			/* TODO */

   375 			FOR_EACH_OBJECT {

   376 				grf_load_byte(&buf);

   377 			}

   378 			ret = true;

   379 		}	break;

   380 		default:

   381 			ret = true;

   382 	}

   383 	*bufp = buf;

   384 	return ret;

   385 }

   386 

   387 static bool RoadVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)

   388 {

   389 	RoadVehicleInfo *rvi = &_road_vehicle_info[engine];

   390 	byte *buf = *bufp;

   391 	int i;

   392 	bool ret = false;

   393 

   394 	switch (prop) {

   395 		case 0x08: {	/* Speed */

   396 			FOR_EACH_OBJECT {

   397 				uint8 speed = grf_load_byte(&buf);

   398 

   399 				rvi[i].max_speed = speed; // ?? units

   400 			}

   401 		}	break;

   402 		case 0x09: {	/* Running cost factor */

   403 			FOR_EACH_OBJECT {

   404 				uint8 runcost = grf_load_byte(&buf);

   405 

   406 				rvi[i].running_cost = runcost;

   407 			}

   408 		}	break;

   409 		case 0x0A:	/* Running cost base */

   410 			/* TODO: I have no idea. --pasky */

   411 			FOR_EACH_OBJECT {

   412 				grf_load_byte(&buf);

   413 			}

   414 			ret = true;

   415 			break;

   416 		case 0x0E: {	/* Sprite ID */

   417 			FOR_EACH_OBJECT {

   418 				uint8 spriteid = grf_load_byte(&buf);

   419 

   420 				if (spriteid == 0xFF)

   421 					spriteid = 0xFD; // cars have different custom id in the GRF file

   422 

   423 				// This is currently not used but there's no reason

   424 				// in not having it here for the future.

   425 				if (spriteid == 0xFD && rvi[i].image_index != 0xFD)

   426 					_engine_original_sprites[ROAD_ENGINES_INDEX + engine + i] = rvi[i].image_index;

   427 

   428 				rvi[i].image_index = spriteid;

   429 			}

   430 		}	break;

   431 		case 0x0F: {	/* Cargo capacity */

   432 			FOR_EACH_OBJECT {

   433 				uint16 capacity = grf_load_word(&buf);

   434 

   435 				rvi[i].capacity = capacity;

   436 			}

   437 		}	break;

   438 		case 0x10: { /* Cargo type */

   439 			FOR_EACH_OBJECT {

   440 				uint8 cargo = grf_load_byte(&buf);

   441 

   442 				rvi[i].cargo_type = cargo;

   443 			}

   444 		}	break;

   445 		case 0x11: {	/* Cost factor */

   446 			FOR_EACH_OBJECT {

   447 				uint8 cost_factor = grf_load_byte(&buf);

   448 

   449 				rvi[i].base_cost = cost_factor; // ?? is it base_cost?

   450 			}

   451 		}	break;

   452 		case 0x12: {	/* SFX */

   453 			FOR_EACH_OBJECT {

   454 				uint8 sfx = grf_load_byte(&buf);

   455 

   456 				rvi[i].sfx = sfx;

   457 			}

   458 		}	break;

   459 		case 0x13:      /* Power in 10hp */

   460 		case 0x14:      /* Weight in 1/4 tons */

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

   462 			/* TODO: Support for road vehicles realistic power

   463 			 * computations (called rvpower in TTDPatch) is just

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

   465 			FOR_EACH_OBJECT {

   466 				grf_load_byte(&buf);

   467 			}

   468 			ret = true;

   469 			break;

   470 		case 0x16: {	/* Cargos available for refitting */

   471 			FOR_EACH_OBJECT {

   472 				uint32 refit_mask = grf_load_dword(&buf);

   473 

   474 				_engine_refit_masks[ROAD_ENGINES_INDEX + engine + i] = refit_mask;

   475 			}

   476 		}	break;

   477 		case 0x17:      /* Callback */

   478 		case 0x18:      /* Tractive effort */

   479 			/* TODO */

   480 			FOR_EACH_OBJECT {

   481 				grf_load_byte(&buf);

   482 			}

   483 			ret = true;

   484 			break;

   485 		default:

   486 			ret = true;

   487 	}

   488 

   489 	*bufp = buf;

   490 	return ret;

   491 }

   492 

   493 static bool ShipVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)

   494 {

   495 	ShipVehicleInfo *svi = &_ship_vehicle_info[engine];

   496 	byte *buf = *bufp;

   497 	int i;

   498 	bool ret = false;

   499 

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

   501 	switch (prop) {

   502 		case 0x08: {	/* Sprite ID */

   503 			FOR_EACH_OBJECT {

   504 				uint8 spriteid = grf_load_byte(&buf);

   505 

   506 				if (spriteid == 0xFF)

   507 					spriteid = 0xFD; // ships have different custom id in the GRF file

   508 

   509 				// This is currently not used but there's no reason

   510 				// in not having it here for the future.

   511 				if (spriteid == 0xFD && svi[i].image_index != 0xFD)

   512 					_engine_original_sprites[SHIP_ENGINES_INDEX + engine + i] = svi[i].image_index;

   513 

   514 				svi[i].image_index = spriteid;

   515 			}

   516 		}	break;

   517 		case 0x09: {	/* Refittable */

   518 			FOR_EACH_OBJECT {

   519 				uint8 refittable = grf_load_byte(&buf);

   520 

   521 				svi[i].refittable = refittable;

   522 			}

   523 		}	break;

   524 		case 0x0A: {	/* Cost factor */

   525 			FOR_EACH_OBJECT {

   526 				uint8 cost_factor = grf_load_byte(&buf);

   527 

   528 				svi[i].base_cost = cost_factor; // ?? is it base_cost?

   529 			}

   530 		}	break;

   531 		case 0x0B: {	/* Speed */

   532 			FOR_EACH_OBJECT {

   533 				uint8 speed = grf_load_byte(&buf);

   534 

   535 				svi[i].max_speed = speed; // ?? units

   536 			}

   537 		}	break;

   538 		case 0x0C: { /* Cargo type */

   539 			FOR_EACH_OBJECT {

   540 				uint8 cargo = grf_load_byte(&buf);

   541 

   542 				// XXX: Need to consult this with patchman yet.

   543 #if 0

   544 				// Documentation claims this is already the

   545 				// per-landscape cargo type id, but newships.grf

   546 				// assume otherwise.

   547 				cargo = local_cargo_id_ctype[cargo];

   548 #endif

   549 				svi[i].cargo_type = cargo;

   550 			}

   551 		}	break;

   552 		case 0x0D: {	/* Cargo capacity */

   553 			FOR_EACH_OBJECT {

   554 				uint16 capacity = grf_load_word(&buf);

   555 

   556 				svi[i].capacity = capacity;

   557 			}

   558 		}	break;

   559 		case 0x0F: {	/* Running cost factor */

   560 			FOR_EACH_OBJECT {

   561 				uint8 runcost = grf_load_byte(&buf);

   562 

   563 				svi[i].running_cost = runcost;

   564 			}

   565 		} break;

   566 		case 0x10: {	/* SFX */

   567 			FOR_EACH_OBJECT {

   568 				uint8 sfx = grf_load_byte(&buf);

   569 

   570 				svi[i].sfx = sfx;

   571 			}

   572 		}	break;

   573 		case 0x11: {	/* Cargos available for refitting */

   574 			FOR_EACH_OBJECT {

   575 				uint32 refit_mask = grf_load_dword(&buf);

   576 

   577 				_engine_refit_masks[SHIP_ENGINES_INDEX + engine + i] = refit_mask;

   578 			}

   579 		}	break;

   580 		case 0x12: { /* Callback TODO */

   581 			ret = true;

   582 		}	break;

   583 		default:

   584 			ret = true;

   585 	}

   586 

   587 	*bufp = buf;

   588 	return ret;

   589 }

   590 

   591 static bool AircraftVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)

   592 {

   593 	AircraftVehicleInfo *avi = &_aircraft_vehicle_info[engine];

   594 	byte *buf = *bufp;

   595 	int i;

   596 	bool ret = false;

   597 

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

   599 	switch (prop) {

   600 		case 0x08: {	/* Sprite ID */

   601 			FOR_EACH_OBJECT {

   602 				uint8 spriteid = grf_load_byte(&buf);

   603 

   604 				if (spriteid == 0xFF)

   605 					spriteid = 0xFD; // ships have different custom id in the GRF file

   606 

   607 				// This is currently not used but there's no reason

   608 				// in not having it here for the future.

   609 				if (spriteid == 0xFD && avi[i].image_index != 0xFD)

   610 					_engine_original_sprites[AIRCRAFT_ENGINES_INDEX + engine + i] = avi[i].image_index;

   611 

   612 				avi[i].image_index = spriteid;

   613 			}

   614 		}	break;

   615 		case 0x09: {	/* Helicopter */

   616 			FOR_EACH_OBJECT {

   617 				uint8 heli = grf_load_byte(&buf);

   618 

   619 				avi[i].subtype = (heli == 0) ? 0 : 1;

   620 			}

   621 		}	break;

   622 		case 0x0A: {	/* Large */

   623 			FOR_EACH_OBJECT {

   624 				uint8 large = grf_load_byte(&buf);

   625 

   626 				avi[i].subtype = (large == 1) ? 3 : 1;

   627 			}

   628 		}	break;

   629 		case 0x0B: {	/* Cost factor */

   630 			FOR_EACH_OBJECT {

   631 				uint8 cost_factor = grf_load_byte(&buf);

   632 

   633 				avi[i].base_cost = cost_factor; // ?? is it base_cost?

   634 			}

   635 		}	break;

   636 		case 0x0C: {	/* Speed */

   637 			FOR_EACH_OBJECT {

   638 				uint8 speed = grf_load_byte(&buf);

   639 

   640 				avi[i].max_speed = speed; // ?? units

   641 			}

   642 		}	break;

   643 		case 0x0D: {	/* Acceleration */

   644 			FOR_EACH_OBJECT {

   645 				uint8 accel = grf_load_byte(&buf);

   646 

   647 				avi[i].acceleration = accel;

   648 			}

   649 		} break;

   650 		case 0x0E: {	/* Running cost factor */

   651 			FOR_EACH_OBJECT {

   652 				uint8 runcost = grf_load_byte(&buf);

   653 

   654 				avi[i].running_cost = runcost;

   655 			}

   656 		} break;

   657 		case 0x0F: {	/* Passenger capacity */

   658 			FOR_EACH_OBJECT {

   659 				uint16 capacity = grf_load_word(&buf);

   660 

   661 				avi[i].passanger_capacity = capacity;

   662 			}

   663 		}	break;

   664 		case 0x11: {	/* Mail capacity */

   665 			FOR_EACH_OBJECT {

   666 				uint8 capacity = grf_load_byte(&buf);

   667 

   668 				avi[i].mail_capacity = capacity;

   669 			}

   670 		}	break;

   671 		case 0x12: {	/* SFX */

   672 			FOR_EACH_OBJECT {

   673 				uint8 sfx = grf_load_byte(&buf);

   674 

   675 				avi[i].sfx = sfx;

   676 			}

   677 		}	break;

   678 		case 0x13: {	/* Cargos available for refitting */

   679 			FOR_EACH_OBJECT {

   680 				uint32 refit_mask = grf_load_dword(&buf);

   681 

   682 				_engine_refit_masks[AIRCRAFT_ENGINES_INDEX + engine + i] = refit_mask;

   683 			}

   684 		}	break;

   685 		case 0x14: { /* Callback TODO */

   686 			ret = true;

   687 		}	break;

   688 		default:

   689 			ret = true;

   690 	}

   691 

   692 	*bufp = buf;

   693 	return ret;

   694 }

   695 

   696 static bool StationChangeInfo(uint stid, int numinfo, int prop, byte **bufp, int len)

   697 {

   698 	byte *buf = *bufp;

   699 	int i;

   700 	int ret = 0;

   701 

   702 	/* This is one single huge TODO. It doesn't handle anything more than

   703 	 * just waypoints for now. */

   704 

   705 	//printf("sci %d %d [0x%02x]\n", stid, numinfo, prop);

   706 	switch (prop) {

   707 		case 0x08:

   708 		{	/* Class ID */

   709 			FOR_EACH_OBJECT {

   710 				struct StationSpec *stat = &_cur_grffile->stations[stid + i];

   711 				uint32 classid;

   712 

   713 				/* classid, for a change, is always little-endian */

   714 				classid = *(buf++) << 24;

   715 				classid |= *(buf++) << 16;

   716 				classid |= *(buf++) << 8;

   717 				classid |= *(buf++);

   718 

   719 				switch (classid) {

   720 					case 'DFLT':

   721 						stat->sclass = STAT_CLASS_DFLT;

   722 						break;

   723 					case 'WAYP':

   724 						stat->sclass = STAT_CLASS_WAYP;

   725 						break;

   726 					default:

   727 						/* TODO: No support for custom

   728 						 * classes for now, so stuff

   729 						 * everything to the single

   730 						 * default one. --pasky */

   731 						stat->sclass = STAT_CLASS_DFLT;

   732 						//stat->sclass = STAT_CLASS_CUSTOM;

   733 						break;

   734 				}

   735 			}

   736 			break;

   737 		}

   738 		case 0x09:

   739 		{	/* Define sprite layout */

   740 			FOR_EACH_OBJECT {

   741 				struct StationSpec *stat = &_cur_grffile->stations[stid + i];

   742 				int t;

   743 

   744 				stat->tiles = grf_load_byte(&buf);

   745 				for (t = 0; t < stat->tiles; t++) {

   746 					DrawTileSprites *dts = &stat->renderdata[t];

   747 					int seq_count = 0;

   748 

   749 					if (t >= 8) {

   750 						grfmsg(GMS_WARN, "StationChangeInfo: Sprite %d>=8, skipping.", t);

   751 						grf_load_dword(&buf); // at least something

   752 						continue;

   753 					}

   754 

   755 					dts->ground_sprite = grf_load_dword(&buf);

   756 					if (!dts->ground_sprite) {

   757 						static const DrawTileSeqStruct empty = {0x80};

   758 						dts->seq = ∅

   759 						continue;

   760 					}

   761 

   762 					dts->seq = NULL;

   763 					while (buf < *bufp + len) {

   764 						DrawTileSeqStruct *dtss;

   765 

   766 						// no relative bounding box support

   767 						dts->seq = realloc((void*)dts->seq, ++seq_count * sizeof(DrawTileSeqStruct));

   768 						dtss = (DrawTileSeqStruct*) &dts->seq[seq_count - 1];

   769 

   770 						dtss->delta_x = grf_load_byte(&buf);

   771 						if ((byte) dtss->delta_x == 0x80) break;

   772 						dtss->delta_y = grf_load_byte(&buf);

   773 						dtss->delta_z = grf_load_byte(&buf);

   774 						dtss->width = grf_load_byte(&buf);

   775 						dtss->height = grf_load_byte(&buf);

   776 						dtss->unk = grf_load_byte(&buf);

   777 						dtss->image = grf_load_dword(&buf) - 0x42d;

   778 					}

   779 				}

   780 			}

   781 			break;

   782 		}

   783 		case 0x0a:

   784 		{	/* Copy sprite layout */

   785 			FOR_EACH_OBJECT {

   786 				struct StationSpec *stat = &_cur_grffile->stations[stid + i];

   787 				byte srcid = grf_load_byte(&buf);

   788 				struct StationSpec *srcstat = &_cur_grffile->stations[srcid];

   789 				int t;

   790 

   791 				stat->tiles = srcstat->tiles;

   792 				for (t = 0; t < stat->tiles; t++) {

   793 					DrawTileSprites *dts = &stat->renderdata[t];

   794 					DrawTileSprites *sdts = &srcstat->renderdata[t];

   795 					DrawTileSeqStruct const *sdtss = sdts->seq;

   796 					int seq_count = 0;

   797 

   798 					dts->ground_sprite = sdts->ground_sprite;

   799 					if (!dts->ground_sprite) {

   800 						static const DrawTileSeqStruct empty = {0x80};

   801 						dts->seq = ∅

   802 						continue;

   803 					}

   804 

   805 					dts->seq = NULL;

   806 					while (1) {

   807 						DrawTileSeqStruct *dtss;

   808 

   809 						// no relative bounding box support

   810 						dts->seq = realloc((void*)dts->seq, ++seq_count * sizeof(DrawTileSeqStruct));

   811 						dtss = (DrawTileSeqStruct*) &dts->seq[seq_count - 1];

   812 						*dtss = *sdtss;

   813 						if ((byte) dtss->delta_x == 0x80) break;

   814 						sdtss++;

   815 					}

   816 				}

   817 			}

   818 			break;

   819 		}

   820 		case 0x0b:

   821 		{	/* Callback */

   822 			/* TODO */

   823 			FOR_EACH_OBJECT {

   824 				grf_load_byte(&buf);

   825 			}

   826 			ret = 1;

   827 			break;

   828 		}

   829 		case 0x0C:

   830 		{	/* Platforms number */

   831 			FOR_EACH_OBJECT {

   832 				struct StationSpec *stat = &_cur_grffile->stations[stid + i];

   833 

   834 				stat->allowed_platforms = ~grf_load_byte(&buf);

   835 			}

   836 			break;

   837 		}

   838 		case 0x0D:

   839 		{	/* Platforms length */

   840 			FOR_EACH_OBJECT {

   841 				struct StationSpec *stat = &_cur_grffile->stations[stid + i];

   842 

   843 				stat->allowed_lengths = ~grf_load_byte(&buf);

   844 			}

   845 			break;

   846 		}

   847 		case 0x0e:

   848 		{	/* Define custom layout */

   849 			FOR_EACH_OBJECT {

   850 				struct StationSpec *stat = &_cur_grffile->stations[stid + i];

   851 

   852 				while (buf < *bufp + len) {

   853 					byte length = grf_load_byte(&buf);

   854 					byte number = grf_load_byte(&buf);

   855 					StationLayout layout;

   856 					int l, p;

   857 

   858 					if (length == 0 || number == 0) break;

   859 

   860 					//debug("l %d > %d ?", length, stat->lengths);

   861 					if (length > stat->lengths) {

   862 						stat->platforms = realloc(stat->platforms, length);

   863 						memset(stat->platforms + stat->lengths, 0, length - stat->lengths);

   864 

   865 						stat->layouts = realloc(stat->layouts, length * sizeof(*stat->layouts));

   866 						memset(stat->layouts + stat->lengths, 0,

   867 						       (length - stat->lengths) * sizeof(*stat->layouts));

   868 

   869 						stat->lengths = length;

   870 					}

   871 					l = length - 1; // index is zero-based

   872 

   873 					//debug("p %d > %d ?", number, stat->platforms[l]);

   874 					if (number > stat->platforms[l]) {

   875 						stat->layouts[l] = realloc(stat->layouts[l],

   876 						                               number * sizeof(**stat->layouts));

   877 						// We expect NULL being 0 here, but C99 guarantees that.

   878 						memset(stat->layouts[l] + stat->platforms[l], 0,

   879 						       (number - stat->platforms[l]) * sizeof(**stat->layouts));

   880 

   881 						stat->platforms[l] = number;

   882 					}

   883 

   884 					layout = malloc(length * number);

   885 					for (l = 0; l < length; l++)

   886 						for (p = 0; p < number; p++)

   887 							layout[l * number + p] = grf_load_byte(&buf);

   888 

   889 					l--;

   890 					p--;

   891 					free(stat->layouts[l][p]);

   892 					stat->layouts[l][p] = layout;

   893 				}

   894 			}

   895 			break;

   896 		}

   897 		case 0x0f:

   898 		{	/* Copy custom layout */

   899 			/* TODO */

   900 			FOR_EACH_OBJECT {

   901 				grf_load_byte(&buf);

   902 			}

   903 			ret = 1;

   904 			break;

   905 		}

   906 		case 0x10:

   907 		{	/* Little/lots cargo threshold */

   908 			/* TODO */

   909 			FOR_EACH_OBJECT {

   910 				grf_load_word(&buf);

   911 			}

   912 			ret = 1;

   913 			break;

   914 		}

   915 		case 0x11:

   916 		{	/* Pylon placement */

   917 			/* TODO; makes sense only for electrified tracks */

   918 			FOR_EACH_OBJECT {

   919 				grf_load_word(&buf);

   920 			}

   921 			ret = 1;

   922 			break;

   923 		}

   924 		case 0x12:

   925 		{	/* Cargo types for random triggers */

   926 			/* TODO */

   927 			FOR_EACH_OBJECT {

   928 				grf_load_dword(&buf);

   929 			}

   930 			ret = 1;

   931 			break;

   932 		}

   933 		default:

   934 			ret = 1;

   935 			break;

   936 	}

   937 

   938 	*bufp = buf;

   939 	return ret;

   940 }

   941 

   942 #undef shift_buf

   943 

   944 

   945 /* Action 0x00 */

   946 static void VehicleChangeInfo(byte *buf, int len)

   947 {

   948 	byte *bufend = buf + len;

   949 	int i;

   950 

   951 	/* <00> <feature> <num-props> <num-info> <id> (<property <new-info>)...

   952 	 *

   953 	 * B feature       0, 1, 2 or 3 for trains, road vehicles, ships or planes

   954 	 *                 4 for defining new train station sets

   955 	 * B num-props     how many properties to change per vehicle/station

   956 	 * B num-info      how many vehicles/stations to change

   957 	 * B id            ID of first vehicle/station to change, if num-info is

   958 	 *                 greater than one, this one and the following

   959 	 *                 vehicles/stations will be changed

   960 	 * B property      what property to change, depends on the feature

   961 	 * V new-info      new bytes of info (variable size; depends on properties) */

   962 	/* TODO: Bridges, town houses. */

   963 

   964 	static const VCI_Handler handler[7] = {

   965 		/* GSF_TRAIN */    RailVehicleChangeInfo,

   966 		/* GSF_ROAD */     RoadVehicleChangeInfo,

   967 		/* GSF_SHIP */     ShipVehicleChangeInfo,

   968 		/* GSF_AIRCRAFT */ AircraftVehicleChangeInfo,

   969 		/* GSF_STATION */  StationChangeInfo,

   970 		/* GSF_BRIDGE */   NULL,

   971 		/* GSF_TOWNHOUSE */NULL,

   972 	};

   973 

   974 	uint8 feature;

   975 	uint8 numprops;

   976 	uint8 numinfo;

   977 	byte engine;

   978 	EngineInfo *ei;

   979 

   980 	if (len == 1) {

   981 		DEBUG(grf, 8) ("Silently ignoring one-byte special sprite 0x00.");

   982 		return;

   983 	}

   984 

   985 	check_length(len, 6, "VehicleChangeInfo");

   986 	feature = buf[1];

   987 	numprops = buf[2];

   988 	numinfo = buf[3];

   989 	engine = buf[4];

   990 

   991 	DEBUG(grf, 6) ("VehicleChangeInfo: Feature %d, %d properties, to apply to %d+%d",

   992 	               feature, numprops, engine, numinfo);

   993 

   994 	if (feature > GSF_STATION) {

   995 		grfmsg(GMS_WARN, "VehicleChangeInfo: Unsupported feature %d, skipping.", feature);

   996 		return;

   997 	}

   998 

   999 	if (feature != GSF_STATION)

  1000 		ei = &_engine_info[engine + _vehshifts[feature]];

  1001 

  1002 	buf += 5;

  1003 

  1004 	while (numprops-- && buf < bufend) {

  1005 		uint8 prop = grf_load_byte(&buf);

  1006 

  1007 		if (feature == GSF_STATION)

  1008 			// stations don't share those common properties

  1009 			goto run_handler;

  1010 

  1011 		switch (prop) {

  1012 		case 0x00: { /* Introduction date */

  1013 			FOR_EACH_OBJECT {

  1014 				uint16 date = grf_load_word(&buf);

  1015 

  1016 				ei[i].base_intro = date;

  1017 			}

  1018 		}	break;

  1019 		case 0x02: { /* Decay speed */

  1020 			FOR_EACH_OBJECT {

  1021 				uint8 decay = grf_load_byte(&buf);

  1022 

  1023 				ei[i].unk2 &= 0x80;

  1024 				ei[i].unk2 |= decay & 0x7f;

  1025 			}

  1026 		}	break;

  1027 		case 0x03: { /* Vehicle life */

  1028 			FOR_EACH_OBJECT {

  1029 				uint8 life = grf_load_byte(&buf);

  1030 

  1031 				ei[i].lifelength = life;

  1032 			}

  1033 		}	break;

  1034 		case 0x04: { /* Model life */

  1035 			FOR_EACH_OBJECT {

  1036 				uint8 life = grf_load_byte(&buf);

  1037 

  1038 				ei[i].base_life = life;

  1039 			}

  1040 		}	break;

  1041 		case 0x06: { /* Climates available */

  1042 			FOR_EACH_OBJECT {

  1043 				uint8 climates = grf_load_byte(&buf);

  1044 

  1045 				ei[i].railtype_climates &= 0xf0;

  1046 				ei[i].railtype_climates |= climates;

  1047 			}

  1048 		}	break;

  1049 		case 0x07: { /* Loading speed */

  1050 			/* TODO */

  1051 			/* Hyronymus explained me what does

  1052 			 * this mean and insists on having a

  1053 			 * credit ;-). --pasky */

  1054 			/* TODO: This needs to be supported by

  1055 			 * LoadUnloadVehicle() first. */

  1056 			FOR_EACH_OBJECT {

  1057 				grf_load_byte(&buf);

  1058 			}

  1059 			goto ignoring;

  1060 		}

  1061 		default: {

  1062 run_handler:

  1063 			if (handler[feature](engine, numinfo, prop, &buf, bufend - buf)) {

  1064 ignoring:

  1065 				grfmsg(GMS_NOTICE, "VehicleChangeInfo: Ignoring property %x (not implemented).", prop);

  1066 			}

  1067 			break;

  1068 		}

  1069 		}

  1070 	}

  1071 #undef shift_buf

  1072 }

  1073 

  1074 #undef FOR_EACH_OBJECT

  1075 

  1076 

  1077 /* Action 0x01 */

  1078 static void NewSpriteSet(byte *buf, int len)

  1079 {

  1080 	/* <01> <feature> <num-sets> <num-ent>

  1081 	 *

  1082 	 * B feature       feature to define sprites for

  1083 	 *                 0, 1, 2, 3: veh-type, 4: train stations

  1084 	 * B num-sets      number of sprite sets

  1085 	 * B num-ent       how many entries per sprite set

  1086 	 *                 For vehicles, this is the number of different

  1087 	 *                         vehicle directions in each sprite set

  1088 	 *                         Set num-dirs=8, unless your sprites are symmetric.

  1089 	 *                         In that case, use num-dirs=4.

  1090 	 *                 For stations, must be 12 (hex) for the eighteen

  1091 	 *                         different sprites that make up a station */

  1092 	/* TODO: No stations support. */

  1093 	uint8 feature;

  1094 

  1095 	check_length(len, 4, "NewSpriteSet");

  1096 	feature = buf[1];

  1097 

  1098 	_cur_grffile->spriteset_start = _cur_spriteid + 1;

  1099 	_cur_grffile->spriteset_feature = feature;

  1100 	_cur_grffile->spriteset_numsets = buf[2];

  1101 	_cur_grffile->spriteset_numents = buf[3];

  1102 }

  1103 

  1104 /* Action 0x02 */

  1105 static void NewSpriteGroup(byte *buf, int len)

  1106 {

  1107 	byte *bufend = buf + len;

  1108 

  1109 	/* <02> <feature> <set-id> <type/num-entries> <feature-specific-data...>

  1110 	 *

  1111 	 * B feature       see action 1

  1112 	 * B set-id        ID of this particular definition

  1113 	 * B type/num-entries

  1114 	 *                 if 80 or greater, this is a randomized or variational

  1115 	 *                 list definition, see below

  1116 	 *                 otherwise it specifies a number of entries, the exact

  1117 	 *                 meaning depends on the feature

  1118 	 * V feature-specific-data (huge mess, don't even look it up --pasky) */

  1119 	/* TODO: No 0x80-types (ugh). */

  1120 	/* TODO: Also, empty sprites aren't handled for now. Need to investigate

  1121 	 * the "opacity" rules for these, that is which sprite to fall back to

  1122 	 * when. --pasky */

  1123 	uint8 feature;

  1124 	uint8 setid;

  1125 	/* XXX: For stations, these two are "little cargo" and "lotsa cargo" sets. */

  1126 	uint8 numloaded;

  1127 	uint8 numloading;

  1128 	struct SpriteGroup *group;

  1129 	struct RealSpriteGroup *rg;

  1130 	byte *loaded_ptr;

  1131 	byte *loading_ptr;

  1132 	int i;

  1133 

  1134 	check_length(len, 5, "NewSpriteGroup");

  1135 	feature = buf[1];

  1136 	setid = buf[2];