Changeset - r3641:bf8cbe28f2dc
[Not reviewed]
master
0 3 0
peter1138 - 18 years ago 2006-04-23 18:27:53
peter1138@openttd.org
(svn r4550) - NewGRF: update string system to new rules: a grf version of less than 6 uses the old scheme, of 7 or more uses the new scheme. (Moving targets, yay...)
3 files changed with 11 insertions and 10 deletions:
0 comments (0 inline, 0 general)
newgrf.c
Show inline comments
 
@@ -1632,222 +1632,223 @@ static void NewVehicle_SpriteGroupMappin
 
	}
 

	
 

	
 
	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;
 
	bool new_scheme = _cur_grffile->grf_version < 7;
 

	
 
	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: {
 
					StringID string = AddGRFString(_cur_grffile->grfid, id, lang, name);
 
					StringID string = AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name);
 
					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>
newgrf_text.c
Show inline comments
 
/* $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,
 
	GRFLX_UNSPECIFIED = 0x7F,
 
} 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.
 

	
 

	
 
/**
 
 * Add the new read stirng into our structure.
 
 * TODO : ajust the old scheme to the new one for german,french and spanish
 
 * Add the new read string into our structure.
 
 */
 
StringID AddGRFString(uint32 grfid, uint16 stringid, byte langid_to_add, const char *text_to_add)
 
StringID AddGRFString(uint32 grfid, uint16 stringid, byte langid_to_add, bool new_scheme, const char *text_to_add)
 
{
 
	GRFText *newtext;
 
	uint id;
 

	
 
	/* When working with the old language scheme (bit 6 of langid is clear) and
 
	/* When working with the old language scheme (grf_version is less than 7) and
 
	 * 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 (!HASBIT(langid_to_add, 6)) {
 
	if (!new_scheme) {
 
		if (HASBITS(langid_to_add, GRFLB_AMERICAN | GRFLB_ENGLISH)) {
 
			langid_to_add = GRFLX_ENGLISH;
 
		} else {
 
			StringID ret = STR_EMPTY;
 
			if (langid_to_add & GRFLB_GERMAN)  ret = AddGRFString(grfid, stringid, 1 << 6 | GRFLX_GERMAN,  text_to_add);
 
			if (langid_to_add & GRFLB_FRENCH)  ret = AddGRFString(grfid, stringid, 1 << 6 | GRFLX_FRENCH,  text_to_add);
 
			if (langid_to_add & GRFLB_SPANISH) ret = AddGRFString(grfid, stringid, 1 << 6 | GRFLX_SPANISH, text_to_add);
 
			if (langid_to_add & GRFLB_GERMAN)  ret = AddGRFString(grfid, stringid, 1 << 6 | GRFLX_GERMAN,  true, text_to_add);
 
			if (langid_to_add & GRFLB_FRENCH)  ret = AddGRFString(grfid, stringid, 1 << 6 | GRFLX_FRENCH,  true, text_to_add);
 
			if (langid_to_add & GRFLB_SPANISH) ret = AddGRFString(grfid, stringid, 1 << 6 | GRFLX_SPANISH, true, text_to_add);
 
			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;
newgrf_text.h
Show inline comments
 
/* $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 AddGRFString(uint32 grfid, uint16 stringid, byte langid, const char *text_to_add);
 
StringID AddGRFString(uint32 grfid, uint16 stringid, byte langid, bool new_scheme, const char *text_to_add);
 
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 */
0 comments (0 inline, 0 general)