}

	for (i = 0; i < idcount; i++) {

		uint8 engine_id = buf[3 + i];

		uint8 engine = engine_id + _vehshifts[feature];

		byte *bp = &buf[4 + idcount];

		if (engine_id > _vehcounts[feature]) {

			grfmsg(GMS_ERROR, "Id %u for feature 0x%02X is out of bounds.", engine_id, feature);

			return;

		}

		DEBUG(grf, 7) ("VehicleMapSpriteGroup: [%d] Engine %d...", i, engine);

		for (c = 0; c < cidcount; c++) {

			uint8 ctype = grf_load_byte(&bp);

			uint16 groupid = grf_load_word(&bp);

			DEBUG(grf, 8) ("VehicleMapSpriteGroup: * [%d] Cargo type 0x%X, group id 0x%02X", c, ctype, groupid);

			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 (ctype == GC_INVALID) ctype = GC_PURCHASE;

			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, ctype, _cur_grffile->spritegroups[groupid]);

				last_engines[i] = engine;

			}

		}

	}

	{

		byte *bp = buf + 4 + idcount + cidcount * 3;

		uint16 groupid = grf_load_word(&bp);

		DEBUG(grf, 8) ("-- Default group id 0x%04X", groupid);

		for (i = 0; i < idcount; i++) {

			uint8 engine = buf[3 + i] + _vehshifts[feature];

			// Don't tell me you don't love duplicated code!

			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;

	}

}

/* Action 0x05 */

static void GraphicsNew(byte *buf, int len)

{

	/* <05> <graphics-type> <num-sprites> <other data...>

	 *

	 * B graphics-type What set of graphics the sprites define.

	 * E num-sprites   How many sprites are in this set?

	 * V other data    Graphics type specific data.  Currently unused. */

	/* TODO */

	uint8 type;

	uint16 num;

	check_length(len, 2, "GraphicsNew");

	buf++;

	type = grf_load_byte(&buf);

	num  = grf_load_extended(&buf);

	switch (type) {

		case 0x04: /* Signal graphics */

			if (num != 112 && num != 240) {

				grfmsg(GMS_WARN, "GraphicsNews: Signal graphics sprite count must be 112 or 240, skipping.");

				return;

			}

			_signal_base = _cur_spriteid;

			break;

		default:

			grfmsg(GMS_NOTICE, "GraphicsNew: Custom graphics (type 0x%02X) sprite block of length %u (unimplemented, ignoring).\n",

					type, num);

			return;

	}

	grfmsg(GMS_NOTICE, "GraphicsNew: Loading %u sprites of type 0x%02X at SpriteID 0x%04X", num, type, _cur_spriteid);

	for (; num > 0; num--) {

		LoadNextSprite(_cur_spriteid++, _file_index);

		_nfo_line++;

	}

}

/* Action 0x06 */

static void CfgApply(byte *buf, int len)

{

	/* <06> <param-num> <param-size> <offset> ... <FF>

/* $Id$ */

/** @file

 * Implementation of  Action 04 "universal holder" structure and functions.

 * This file implements a linked-lists of strings,

 * holding everything that the newgrf action 04 will send over to OpenTTD.

 * One of the biggest problems is that Dynamic lang Array uses ISO codes

 * as way to identifying current user lang, while newgrf uses bit shift codes

 * not related to ISO.  So equivalence functionnality had to be set.

 */

#include "stdafx.h"

#include "debug.h"

#include "openttd.h"

#include "string.h"

#include "variables.h"

#include "macros.h"

#include "table/strings.h"

#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;

		}

	}

	return STR_UNDEFINED;

}

char *GetGRFString(char *buff, uint16 stringid)

{

	GRFText *search_text;

	assert(_grf_text[stringid].grfid != 0);

	/*Search the list of lang-strings of this stringid for current lang */

	for (search_text = _grf_text[stringid].textholder; search_text != NULL; search_text = search_text->next) {

		if (search_text->langid == _currentLangID){

			return strecpy(buff, search_text->text, NULL);

		}

	}

	/* Use the first text if the specific language isn't available */

	return strecpy(buff, _grf_text[stringid].textholder->text, NULL);

}

/**

 * Equivalence Setter function between game and newgrf langID.

 * This function will adjust _currentLangID as to what is the LangID

 * of the current language set by the user.

 * The array iso_codes will be used to find that match.

 * If not found, it will have to be standard english

 * This function is called after the user changed language,

 * from strings.c:ReadLanguagePack

 * @param iso code of current selection

 */

void SetCurrentGrfLangID(const char *iso_name)

{

	byte ret,i;

	/* Use English by default, if we can't match up the iso_code. */

	ret = GRFLX_ENGLISH;

	for (i=0; i < lengthof(iso_codes); i++) {

		if (strcmp(iso_codes[i].code, iso_name) == 0) {

			/* We found a match, so let's use it. */

			ret = i;

			break;

		}

	}

	_currentLangID = ret;

/* $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 */