if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {

				grfmsg(GMS_WARN, "VehicleMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping.", groupid, _cur_grffile->spritegroups_count);

				return;

			}

			if (wagover) {

				// TODO: No multiple cargo types per vehicle yet. --pasky

				SetWagonOverrideSprites(engine, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);

			} else {

				SetCustomEngineSprites(engine, GC_DEFAULT, _cur_grffile->spritegroups[groupid]);

				last_engines[i] = engine;

			}

		}

	}

}

/* Action 0x04 */

static void VehicleNewName(byte *buf, int len)

{

	/* <04> <veh-type> <language-id> <num-veh> <offset> <data...>

	 *

	 * B veh-type      see action 0 (as 00..07, + 0A

	 *                 But IF veh-type = 48, then generic text

	 * B language-id   If bit 6 is set, This is the extended language scheme,

	                   with up to 64 language.

	                   Otherwise, it is a mapping where set bits have meaning

	                   0 = american, 1 = english, 2 = german, 3 = french, 4 = spanish

	                   Bit 7 set means this is a generic text, not a vehicle one (or else)

	 * B num-veh       number of vehicles which are getting a new name

	 * B/W offset      number of the first vehicle that gets a new name

	 *                 Byte : ID of vehicle to change

	 *                 Word : ID of string to change/add

	 * S data          new texts, each of them zero-terminated, after

	 *                 which the next name begins. */

	/* TODO: No support for changing non-vehicle text. Perhaps we shouldn't

	 * implement it at all, but it could be useful for some "modpacks"

	 * (completely new scenarios changing all graphics and logically also

	 * factory names etc). We should then also support all languages (by

	 * name), not only the original four ones. --pasky

	 * TODO: Support for custom station class/type names.

	 * All of the above are coming.  In Time.  Some sooner than others :)*/

	uint8 feature;

	uint8 lang;

	uint8 num;

	uint16 id;

	uint16 endid;

	const char* name;

	check_length(len, 6, "VehicleNewName");

	buf++;

	feature  = grf_load_byte(&buf);

	lang     = grf_load_byte(&buf);

	num      = grf_load_byte(&buf);

	id       = (lang & 0x80) ? grf_load_word(&buf) : grf_load_byte(&buf);

	if (feature < GSF_AIRCRAFT+1) {

		id += _vehshifts[feature];

	}

	endid    = id + num;

	DEBUG(grf, 6) ("VehicleNewName: About to rename engines %d..%d (feature %d) in language 0x%02X.",

	               id, endid, feature, lang);

	name = (const char*)buf; /*transfer read value*/

	len -= (lang & 0x80) ? 6 : 5;

	for (; id < endid && len > 0; id++) {

		size_t ofs = strlen(name) + 1;

		if (ofs < 128) {

			DEBUG(grf, 8) ("VehicleNewName: %d <- %s", id, name);

			switch (feature) {

				case GSF_TRAIN:

				case GSF_ROAD:

				case GSF_SHIP:

				case GSF_AIRCRAFT: {

					if (id < TOTAL_NUM_ENGINES) SetCustomEngineName(id, string);

					break;

				}

#if 0

				case GSF_STATION:

					switch (GB(id, 8, 8)) {

						case 0xC4: { /* Station class name */

							StationClassID sclass = _cur_grffile->stations[GB(id, 0, 8)].sclass;

							SetStationClassName(sclass, AddGRFString(_cur_grffile->grfid, id, lang, name));

							break;

						}

						case 0xC5:   /* Station name */

							_cur_grffile->stations[GB(id, 0, 8)].name = AddGRFString(_cur_grffile->grfid, id, lang, name);

							break;

						default:

							DEBUG(grf, 7) ("VehicleNewName: Unsupported ID (0x%04X)", id);

							break;

					}

					break;

				case GSF_CANAL :

				case GSF_BRIDGE :

				case GSF_TOWNHOUSE :

					AddGRFString(_cur_spriteid, id, lang, name);

					switch (GB(id, 8,8)) {

						case 0xC9: /* House name */

						default:

							DEBUG(grf, 7) ("VehicleNewName: Unsupported ID (0x%04X)", id);

					}

					break;

				case GSF_INDUSTRIES :

				case 0x48 :   /* for generic strings */

					AddGRFString(_cur_spriteid, id, lang, name);

					break;

				default :

					DEBUG(grf,7) ("VehicleNewName: Unsupported feature (0x%02X)", feature);

					break;

#endif

			}

		} else {

			DEBUG(grf, 7) ("VehicleNewName: Too long a name (%d)", ofs);

		}

		name += ofs;

		len -= ofs;

#include "newgrf_text.h"

#define GRFTAB  28

#define TABSIZE 11

/**

 * Explains the newgrf shift bit positionning.

 * the grf base will not be used in order to find the string, but rather for

 * jumping from standard langID scheme to the new one.

 */

typedef enum grf_base_languages {

	GRFLB_AMERICAN    = 0x01,

	GRFLB_ENGLISH     = 0x02,

	GRFLB_GERMAN      = 0x04,

	GRFLB_FRENCH      = 0x08,

	GRFLB_SPANISH     = 0x10,

	GRFLB_GENERIC     = 0x80,

} grf_base_language;

typedef enum grf_extended_languages {

	GRFLX_AMERICAN    = 0x00,

	GRFLX_ENGLISH     = 0x01,

	GRFLX_GERMAN      = 0x02,

	GRFLX_FRENCH      = 0x03,

	GRFLX_SPANISH     = 0x04,

	GRFLX_RUSSIAN     = 0x07,

	GRFLX_CZECH       = 0x15,

	GRFLX_SLOVAK      = 0x16,

	GRFLX_DUTCH       = 0x1F,

	GRFLX_CATALAN     = 0x22,

	GRFLX_HUNGARIAN   = 0x24,

	GRFLX_ITALIAN     = 0x27,

	GRFLX_ROMANIAN    = 0x28,

	GRFLX_ICELANDIC   = 0x29,

	GRFLX_LATVIAN     = 0x2A,

	GRFLX_LITHUANIAN  = 0x2B,

	GRFLX_SLOVENIAN   = 0x2C,

	GRFLX_DANISH      = 0x2D,

	GRFLX_SWEDISH     = 0x2E,

	GRFLX_NORWEGIAN   = 0x2F,

	GRFLX_POLISH      = 0x30,

	GRFLX_GALICIAN    = 0x31,

	GRFLX_FRISIAN     = 0x32,

	GRFLX_ESTONIAN    = 0x34,

	GRFLX_FINNISH     = 0x35,

	GRFLX_PORTUGUESE  = 0x36,

	GRFLX_BRAZILIAN   = 0x37,

	GRFLX_TURKISH     = 0x3E,

} grf_language;

typedef struct iso_grf {

	char code[6];

	byte grfLangID;

} iso_grf;

/**

 * ISO code VS NewGrf langID conversion array.

 * This array is used in two ways:

 * 1-its ISO part is matching OpenTTD dynamic language id

 *   with newgrf bit positionning language id

 * 2-its shift part is used to know what is the shift to

 *   watch for when inserting new strings, hence analysing newgrf langid

 */

const iso_grf iso_codes[] = {

	{"en_US", GRFLX_AMERICAN},

	{"en_GB", GRFLX_ENGLISH},

	{"de",    GRFLX_GERMAN},

	{"fr",    GRFLX_FRENCH},

	{"es",    GRFLX_SPANISH},

	{"cs",    GRFLX_CZECH},

	{"ca",    GRFLX_CATALAN},

	{"da",    GRFLX_DANISH},

	{"nl",    GRFLX_DUTCH},

	{"et",    GRFLX_ESTONIAN},

	{"fi",    GRFLX_FINNISH},

	{"fy",    GRFLX_FRISIAN},

	{"gl",    GRFLX_GALICIAN},

	{"hu",    GRFLX_HUNGARIAN},

	{"is",    GRFLX_ICELANDIC},

	{"it",    GRFLX_ITALIAN},

	{"lv",    GRFLX_LATVIAN},

	{"lt",    GRFLX_LITHUANIAN},

	{"nb",    GRFLX_NORWEGIAN},

	{"pl",    GRFLX_POLISH},

	{"pt",    GRFLX_PORTUGUESE},

	{"pt_BR", GRFLX_BRAZILIAN},

	{"ro",    GRFLX_ROMANIAN},

	{"ru",    GRFLX_RUSSIAN},

	{"sk",    GRFLX_SLOVAK},

	{"sl",    GRFLX_SLOVENIAN},

	{"sv",    GRFLX_SWEDISH},

	{"tr",    GRFLX_TURKISH},

	{"gen",   GRFLB_GENERIC}   //this is not iso code, but there has to be something...

};

static uint _num_grf_texts = 0;

static GRFTextEntry _grf_text[(1 << TABSIZE) * 3];

static byte _currentLangID = GRFLX_ENGLISH;  //by default, english is used.

/**

 */

{

	GRFText *newtext;

	uint id;

	 * English or American is among the set bits, simply add it as English in

	 * the new scheme, i.e. as langid = 1.

	 * If English is set, it is pretty safe to assume the translations are not

	 * actually translated.

	 */

		if (HASBITS(langid_to_add, GRFLB_AMERICAN | GRFLB_ENGLISH)) {

			langid_to_add = GRFLX_ENGLISH;

		} else {

			StringID ret = STR_EMPTY;

			return ret;

		}

	}

	newtext = calloc(1, sizeof(*newtext));

	newtext->langid = GB(langid_to_add, 0, 6);

	newtext->text   = strdup(text_to_add);

	newtext->next   = NULL;

	str_validate(newtext->text);

	for (id = 0; id < _num_grf_texts; id++) {

		if (_grf_text[id].grfid == grfid && _grf_text[id].stringid == stringid) {

			break;

		}

	}

	/* Too many strings allocated, return empty */

	if (id == lengthof(_grf_text)) return STR_EMPTY;

	/* If we didn't find our stringid and grfid in the list, allocate a new id */

	if (id == _num_grf_texts) _num_grf_texts++;

	if (_grf_text[id].textholder == NULL) {

		_grf_text[id].grfid      = grfid;

		_grf_text[id].stringid   = stringid;

		_grf_text[id].textholder = newtext;

	} else {

		GRFText *textptr = _grf_text[id].textholder;

		while (textptr->next != NULL) textptr = textptr->next;

		textptr->next = newtext;

	}

	DEBUG(grf, 2)("Added 0x%X: grfid 0x%X string 0x%X lang 0x%X string %s", id, grfid, stringid, newtext->langid, newtext->text);

	return (GRFTAB << TABSIZE) + id;

}

/**

 * Returns the index for this stringid associated with its grfID

 */

StringID GetGRFStringID(uint32 grfid, uint16 stringid)

{

	uint id;

	for (id = 0; id < _num_grf_texts; id++) {

		if (_grf_text[id].grfid == grfid && _grf_text[id].stringid == stringid) {

			return (GRFTAB << TABSIZE) + id;

/* $Id$ */

#ifndef NEWGRF_TEXT_H

#define NEWGRF_TEXT_H

/** @file

 * Header of Action 04 "universal holder" structure and functions

 */

/**

 * Element of the linked list.

 * Each of those elements represent the string,

 * but according to a different lang.

 */

typedef struct GRFText {

	byte langid;

	char *text;

	struct GRFText *next;

} GRFText;

/**

 * Holder of the above structure.

 * Putting both grfid and stringid togueter allow us to avoid duplicates,

 * since it is NOT SUPPOSED to happen.

 */

typedef struct GRFTextEntry {

	uint32 grfid;

	uint16 stringid;

	GRFText *textholder;

} GRFTextEntry;

StringID GetGRFStringID(uint32 grfid, uint16 stringid);

char *GetGRFString(char *buff, uint16 stringid);

void CleanUpStrings(void);

void SetCurrentGrfLangID(const char *iso_name);

#endif /* NEWGRF_TEXT_H */