1

/* $Id$ */

     2

     3

/** @file gfxinit.cpp Initializing of the (GRF) graphics. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "gfxinit.h"

     9

#include "spritecache.h"

    10

#include "fileio_func.h"

    11

#include "fios.h"

    12

#include "newgrf.h"

    13

#include "md5.h"

    14

#include "variables.h"

    15

#include "fontcache.h"

    16

#include "gfx_func.h"

    17

#include "core/alloc_func.hpp"

    18

#include "core/bitmath_func.hpp"

    19

#include "core/smallvec_type.hpp"

    20

#include <string.h>

    21

#include "settings_type.h"

    22

#include "string_func.h"

    23

#include "ini_type.h"

    24

    25

#include "table/sprites.h"

    26

#include "table/palette_convert.h"

    27

    28

/** The currently used palette */

    29

PaletteType _use_palette = PAL_AUTODETECT;

    30

/** Whether the given NewGRFs must get a palette remap or not. */

    31

bool _palette_remap_grf[MAX_FILE_SLOTS];

    32

/** Palette map to go from the !_use_palette to the _use_palette */

    33

const byte *_palette_remap = NULL;

    34

/** Palette map to go from the _use_palette to the !_use_palette */

    35

const byte *_palette_reverse_remap = NULL;

    36

    37

char _ini_graphics_set[32];

    38

    39

/** Structure holding filename and MD5 information about a single file */

    40

struct MD5File {

    41

	const char *filename;        ///< filename

    42

	uint8 hash[16];              ///< md5 sum of the file

    43

	const char *missing_warning; ///< warning when this file is missing

    44

};

    45

    46

/** Types of graphics in the base graphics set */

    47

enum GraphicsFileType {

    48

	GFT_BASE,     ///< Base sprites for all climates

    49

	GFT_LOGOS,    ///< Logos, landscape icons and original terrain generator sprites

    50

	GFT_ARCTIC,   ///< Landscape replacement sprites for arctic

    51

	GFT_TROPICAL, ///< Landscape replacement sprites for tropical

    52

	GFT_TOYLAND,  ///< Landscape replacement sprites for toyland

    53

	GFT_EXTRA,    ///< Extra sprites that were not part of the original sprites

    54

	MAX_GFT       ///< We are looking for this amount of GRFs

    55

};

    56

    57

/** Information about a single graphics set. */

    58

struct GraphicsSet {

    59

	const char *name;          ///< The name of the graphics set

    60

	const char *description;   ///< Description of the graphics set

    61

	uint32 shortname;          ///< Four letter short variant of the name

    62

	uint32 version;            ///< The version of this graphics set

    63

	PaletteType palette;       ///< Palette of this graphics set

    64

    65

	MD5File files[MAX_GFT];    ///< All GRF files part of this set

    66

	uint found_grfs;           ///< Number of the GRFs that could be found

    67

    68

	GraphicsSet *next;         ///< The next graphics set in this list

    69

    70

	/** Free everything we allocated */

    71

	~GraphicsSet()

    72

	{

    73

		free((void*)this->name);

    74

		free((void*)this->description);

    75

		for (uint i = 0; i < MAX_GFT; i++) {

    76

			free((void*)this->files[i].filename);

    77

			free((void*)this->files[i].missing_warning);

    78

		}

    79

    80

		delete this->next;

    81

	}

    82

};

    83

    84

/** All graphics sets currently available */

    85

static GraphicsSet *_available_graphics_sets = NULL;

    86

/** The one and only graphics set that is currently being used. */

    87

static const GraphicsSet *_used_graphics_set = NULL;

    88

    89

#include "table/files.h"

    90

#include "table/landscape_sprite.h"

    91

    92

static const SpriteID * const _landscape_spriteindexes[] = {

    93

	_landscape_spriteindexes_1,

    94

	_landscape_spriteindexes_2,

    95

	_landscape_spriteindexes_3,

    96

};

    97

    98

static uint LoadGrfFile(const char *filename, uint load_index, int file_index)

    99

{

   100

	uint load_index_org = load_index;

   101

	uint sprite_id = 0;

   102

   103

	FioOpenFile(file_index, filename);

   104

   105

	DEBUG(sprite, 2, "Reading grf-file '%s'", filename);

   106

   107

	while (LoadNextSprite(load_index, file_index, sprite_id)) {

   108

		load_index++;

   109

		sprite_id++;

   110

		if (load_index >= MAX_SPRITES) {

   111

			usererror("Too many sprites. Recompile with higher MAX_SPRITES value or remove some custom GRF files.");

   112

		}

   113

	}

   114

	DEBUG(sprite, 2, "Currently %i sprites are loaded", load_index);

   115

   116

	return load_index - load_index_org;

   117

}

   118

   119

   120

void LoadSpritesIndexed(int file_index, uint *sprite_id, const SpriteID *index_tbl)

   121

{

   122

	uint start;

   123

	while ((start = *index_tbl++) != END) {

   124

		uint end = *index_tbl++;

   125

   126

		do {

   127

			bool b = LoadNextSprite(start, file_index, *sprite_id);

   128

			assert(b);

   129

			(*sprite_id)++;

   130

		} while (++start <= end);

   131

	}

   132

}

   133

   134

static void LoadGrfIndexed(const char* filename, const SpriteID* index_tbl, int file_index)

   135

{

   136

	uint sprite_id = 0;

   137

   138

	FioOpenFile(file_index, filename);

   139

   140

	DEBUG(sprite, 2, "Reading indexed grf-file '%s'", filename);

   141

   142

	LoadSpritesIndexed(file_index, &sprite_id, index_tbl);

   143

}

   144

   145

   146

/**

   147

 * Calculate and check the MD5 hash of the supplied filename.

   148

 * @param file filename and expected MD5 hash for the given filename.

   149

 * @return true if the checksum is correct.

   150

 */

   151

static bool FileMD5(const MD5File file)

   152

{

   153

	size_t size;

   154

	FILE *f = FioFOpenFile(file.filename, "rb", DATA_DIR, &size);

   155

   156

	if (f != NULL) {

   157

		Md5 checksum;

   158

		uint8 buffer[1024];

   159

		uint8 digest[16];

   160

		size_t len;

   161

   162

		while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, f)) != 0 && size != 0) {

   163

			size -= len;

   164

			checksum.Append(buffer, len);

   165

		}

   166

   167

		FioFCloseFile(f);

   168

   169

		checksum.Finish(digest);

   170

		return memcmp(file.hash, digest, sizeof(file.hash)) == 0;

   171

	} else { // file not found

   172

		return false;

   173

	}

   174

}

   175

   176

/**

   177

 * Determine the graphics pack that has to be used.

   178

 * The one with the most correct files wins.

   179

 */

   180

static bool DetermineGraphicsPack()

   181

{

   182

	if (_used_graphics_set != NULL) return true;

   183

   184

	const GraphicsSet *best = _available_graphics_sets;

   185

	for (const GraphicsSet *c = _available_graphics_sets; c != NULL; c = c->next) {

   186

		if (best->found_grfs < c->found_grfs ||

   187

				(best->found_grfs == c->found_grfs && (

   188

					(best->shortname == c->shortname && best->version < c->version) ||

   189

					(best->palette != _use_palette && c->palette == _use_palette)))) {

   190

			best = c;

   191

		}

   192

	}

   193

   194

	_used_graphics_set = best;

   195

	return _used_graphics_set != NULL;

   196

}

   197

   198

extern void UpdateNewGRFConfigPalette();

   199

   200

/**

   201

 * Determine the palette that has to be used.

   202

 *  - forced palette via command line -> leave it that way

   203

 *  - otherwise -> palette based on the graphics pack

   204

 */

   205

static void DeterminePalette()

   206

{

   207

	assert(_used_graphics_set != NULL);

   208

	if (_use_palette >= MAX_PAL) _use_palette = _used_graphics_set->palette;

   209

   210

	switch (_use_palette) {

   211

		case PAL_DOS:

   212

			_palette_remap = _palmap_w2d;

   213

			_palette_reverse_remap = _palmap_d2w;

   214

			break;

   215

   216

		case PAL_WINDOWS:

   217

			_palette_remap = _palmap_d2w;

   218

			_palette_reverse_remap = _palmap_w2d;

   219

			break;

   220

   221

		default:

   222

			NOT_REACHED();

   223

	}

   224

   225

	UpdateNewGRFConfigPalette();

   226

}

   227

   228

/**

   229

 * Checks whether the MD5 checksums of the files are correct.

   230

 *

   231

 * @note Also checks sample.cat and other required non-NewGRF GRFs for corruption.

   232

 */

   233

void CheckExternalFiles()

   234

{

   235

	DeterminePalette();

   236

   237

	DEBUG(grf, 1, "Using the %s base graphics set with the %s palette", _used_graphics_set->name, _use_palette == PAL_DOS ? "DOS" : "Windows");

   238

   239

	static const size_t ERROR_MESSAGE_LENGTH = 128;

   240

	char error_msg[ERROR_MESSAGE_LENGTH * (MAX_GFT + 1)];

   241

	error_msg[0] = '\0';

   242

	char *add_pos = error_msg;

   243

	const char *last = lastof(error_msg);

   244

   245

	for (uint i = 0; i < lengthof(_used_graphics_set->files); i++) {

   246

		if (!FileMD5(_used_graphics_set->files[i])) {

   247

			add_pos += seprintf(add_pos, last, "Your '%s' file is corrupted or missing! %s\n", _used_graphics_set->files[i].filename, _used_graphics_set->files[i].missing_warning);

   248

		}

   249

	}

   250

   251

	bool sound = false;

   252

	for (uint i = 0; !sound && i < lengthof(_sound_sets); i++) {

   253

		sound = FileMD5(_sound_sets[i]);

   254

	}

   255

   256

	if (!sound) {

   257

		add_pos += seprintf(add_pos, last, "Your 'sample.cat' file is corrupted or missing! You can find 'sample.cat' on your Transport Tycoon Deluxe CD-ROM.\n");

   258

	}

   259

   260

	if (add_pos != error_msg) ShowInfoF(error_msg);

   261

}

   262

   263

   264

static void LoadSpriteTables()

   265

{

   266

	memset(_palette_remap_grf, 0, sizeof(_palette_remap_grf));

   267

	uint i = FIRST_GRF_SLOT;

   268

   269

	_palette_remap_grf[i] = (_use_palette != _used_graphics_set->palette);

   270

	LoadGrfFile(_used_graphics_set->files[GFT_BASE].filename, 0, i++);

   271

   272

	/*

   273

	 * The second basic file always starts at the given location and does

   274

	 * contain a different amount of sprites depending on the "type"; DOS

   275

	 * has a few sprites less. However, we do not care about those missing

   276

	 * sprites as they are not shown anyway (logos in intro game).

   277

	 */

   278

	_palette_remap_grf[i] = (_use_palette != _used_graphics_set->palette);

   279

	LoadGrfFile(_used_graphics_set->files[GFT_LOGOS].filename, 4793, i++);

   280

   281

	/*

   282

	 * Load additional sprites for climates other than temperate.

   283

	 * This overwrites some of the temperate sprites, such as foundations

   284

	 * and the ground sprites.

   285

	 */

   286

	if (_settings_game.game_creation.landscape != LT_TEMPERATE) {

   287

		_palette_remap_grf[i] = (_use_palette != _used_graphics_set->palette);

   288

		LoadGrfIndexed(

   289

			_used_graphics_set->files[GFT_ARCTIC + _settings_game.game_creation.landscape - 1].filename,

   290

			_landscape_spriteindexes[_settings_game.game_creation.landscape - 1],

   291

			i++

   292

		);

   293

	}

   294

   295

	/* Initialize the unicode to sprite mapping table */

   296

	InitializeUnicodeGlyphMap();

   297

   298

	/*

   299

	 * Load the base NewGRF with OTTD required graphics as first NewGRF.

   300

	 * However, we do not want it to show up in the list of used NewGRFs,

   301

	 * so we have to manually add it, and then remove it later.

   302

	 */

   303

	GRFConfig *top = _grfconfig;

   304

	GRFConfig *master = CallocT<GRFConfig>(1);

   305

	master->filename = strdup(_used_graphics_set->files[GFT_EXTRA].filename);

   306

	FillGRFDetails(master, false);

   307

	master->windows_paletted = (_used_graphics_set->palette == PAL_WINDOWS);

   308

	ClrBit(master->flags, GCF_INIT_ONLY);

   309

	master->next = top;

   310

	_grfconfig = master;

   311

   312

	LoadNewGRF(SPR_NEWGRFS_BASE, i);

   313

   314

	/* Free and remove the top element. */

   315

	ClearGRFConfig(&master);

   316

	_grfconfig = top;

   317

}

   318

   319

   320

void GfxLoadSprites()

   321

{

   322

	DEBUG(sprite, 2, "Loading sprite set %d", _settings_game.game_creation.landscape);

   323

   324

	GfxInitSpriteMem();

   325

	LoadSpriteTables();

   326

	GfxInitPalettes();

   327

}

   328

   329

/**

   330

 * Try to read a single piece of metadata and return false if it doesn't exist.

   331

 * @param name the name of the item to fetch.

   332

 */

   333

#define fetch_metadata(name) \

   334

	item = metadata->GetItem(name, false); \

   335

	if (item == NULL || strlen(item->value) == 0) { \

   336

		DEBUG(grf, 0, "Base graphics set detail loading: %s field missing", name); \

   337

		return false; \

   338

	}

   339

   340

/** Names corresponding to the GraphicsFileType */

   341

static const char *_gft_names[MAX_GFT] = { "base", "logos", "arctic", "tropical", "toyland", "extra" };

   342

   343

/**

   344

 * Read the graphics set information from a loaded ini.

   345

 * @param graphics the graphics set to write to

   346

 * @param ini      the ini to read from

   347

 * @param path     the path to this ini file (for filenames)

   348

 * @return true if loading was successful.

   349

 */

   350

static bool FillGraphicsSetDetails(GraphicsSet *graphics, IniFile *ini, const char *path)

   351

{

   352

	memset(graphics, 0, sizeof(*graphics));

   353

   354

	IniGroup *metadata = ini->GetGroup("metadata");

   355

	IniItem *item;

   356

   357

	fetch_metadata("name");

   358

	graphics->name = strdup(item->value);

   359

   360

	fetch_metadata("description");

   361

	graphics->description = strdup(item->value);

   362

   363

	fetch_metadata("shortname");

   364

	for (uint i = 0; item->value[i] != '\0' && i < 4; i++) {

   365

		graphics->shortname |= ((uint8)item->value[i]) << (32 - i * 8);

   366

	}

   367

   368

	fetch_metadata("version");

   369

	graphics->version = atoi(item->value);

   370

   371

	fetch_metadata("palette");

   372

	graphics->palette = (*item->value == 'D' || *item->value == 'd') ? PAL_DOS : PAL_WINDOWS;

   373

   374

	/* For each of the graphics file types we want to find the file, MD5 checksums and warning messages. */

   375

	IniGroup *files  = ini->GetGroup("files");

   376

	IniGroup *md5s   = ini->GetGroup("md5s");

   377

	IniGroup *origin = ini->GetGroup("origin");

   378

	for (uint i = 0; i < MAX_GFT; i++) {

   379

		MD5File *file = &graphics->files[i];

   380

		/* Find the filename first. */

   381

		item = files->GetItem(_gft_names[i], false);

   382

		if (item == NULL) {

   383

			DEBUG(grf, 0, "No graphics file for: %s", _gft_names[i]);

   384

			return false;

   385

		}

   386

   387

		const char *filename = item->value;

   388

		file->filename = MallocT<char>(strlen(filename) + strlen(path) + 1);

   389

		sprintf((char*)file->filename, "%s%s", path, filename);

   390

   391

		/* Then find the MD5 checksum */

   392

		item = md5s->GetItem(filename, false);

   393

		if (item == NULL) {

   394

			DEBUG(grf, 0, "No MD5 checksum specified for: %s", filename);

   395

			return false;

   396

		}

   397

		char *c = item->value;

   398

		for (uint i = 0; i < sizeof(file->hash) * 2; i++, c++) {

   399

			uint j;

   400

			if ('0' <= *c && *c <= '9') {

   401

				j = *c - '0';

   402

			} else if ('a' <= *c && *c <= 'f') {

   403

				j = *c - 'a' + 10;

   404

			} else if ('A' <= *c && *c <= 'F') {

   405

				j = *c - 'A' + 10;

   406

			} else {

   407

				DEBUG(grf, 0, "Malformed MD5 checksum specified for: %s", filename);

   408

				return false;

   409

			}

   410

			if (i % 2 == 0) {

   411

				file->hash[i / 2] = j << 4;

   412

			} else {

   413

				file->hash[i / 2] |= j;

   414

			}

   415

		}

   416

   417

		/* Then find the warning message when the file's missing */

   418

		item = origin->GetItem(filename, false);

   419

		if (item == NULL) item = origin->GetItem("default", false);

   420

		if (item == NULL) {

   421

			DEBUG(grf, 1, "No origin warning message specified for: %s", filename);

   422

			file->missing_warning = strdup("");

   423

		} else {

   424

			file->missing_warning = strdup(item->value);

   425

		}

   426

   427

		if (FileMD5(*file)) graphics->found_grfs++;

   428

	}

   429

   430

	return true;

   431

}

   432

   433

/** Helper for scanning for files with GRF as extension */

   434

class OBGFileScanner : FileScanner {

   435

public:

   436

	/* virtual */ bool AddFile(const char *filename, size_t basepath_length);

   437

   438

	/** Do the scan for OBGs. */

   439

	static uint DoScan()

   440

	{

   441

		OBGFileScanner fs;

   442

		return fs.Scan(".obg", DATA_DIR);

   443

	}

   444

};

   445

   446

/**

   447

 * Try to add a graphics set with the given filename.

   448

 * @param filename        the full path to the file to read

   449

 * @param basepath_length amount of characters to chop of before to get a relative DATA_DIR filename

   450

 * @return true if the file is added.

   451

 */

   452

bool OBGFileScanner::AddFile(const char *filename, size_t basepath_length)

   453

{

   454

	bool ret = false;

   455

	DEBUG(grf, 1, "Found %s as base graphics set", filename);

   456

   457

	GraphicsSet *graphics = new GraphicsSet();;

   458

	IniFile *ini = new IniFile();

   459

	ini->LoadFromDisk(filename);

   460

   461

	char *path = strdup(filename + basepath_length);

   462

	char *psep = strrchr(path, PATHSEPCHAR);

   463

	if (psep != NULL) {

   464

		psep[1] = '\0';

   465

	} else {

   466

		*path = '\0';

   467

	}

   468

   469

	if (FillGraphicsSetDetails(graphics, ini, path)) {

   470

		bool duplicate = false;

   471

		for (const GraphicsSet *c = _available_graphics_sets; !duplicate && c != NULL; c = c->next) {

   472

			duplicate = (strcmp(c->name, graphics->name) == 0) || (c->shortname == graphics->shortname && c->version == graphics->version);

   473

		}

   474

		if (duplicate) {

   475

			delete graphics;

   476

		} else {

   477

			graphics->next = _available_graphics_sets;

   478

			_available_graphics_sets = graphics;

   479

			ret = true;

   480

		}

   481

	} else {

   482

		delete graphics;

   483

	}

   484

	free(path);

   485

   486

	delete ini;

   487

	return ret;