1

/* $Id$ */

     2

     3

/** @file gfxinit.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "gfxinit.h"

     9

#include "spritecache.h"

    10

#include "table/sprites.h"

    11

#include "fileio.h"

    12

#include "fios.h"

    13

#include "string.h"

    14

#include "newgrf.h"

    15

#include "md5.h"

    16

#include "variables.h"

    17

#include "fontcache.h"

    18

#include "gfx_func.h"

    19

#include <string.h>

    20

    21

struct MD5File {

    22

	const char * filename;     ///< filename

    23

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

    24

};

    25

    26

struct FileList {

    27

	MD5File basic[2];     ///< GRF files that always have to be loaded

    28

	MD5File landscape[3]; ///< Landscape specific grf files

    29

	MD5File sound;        ///< Sound samples

    30

	MD5File chars;        ///< GRF File with character replacements

    31

	MD5File openttd;      ///< GRF File with OTTD specific graphics

    32

};

    33

    34

#include "table/files.h"

    35

#include "table/landscape_sprite.h"

    36

    37

static const SpriteID * const _landscape_spriteindexes[] = {

    38

	_landscape_spriteindexes_1,

    39

	_landscape_spriteindexes_2,

    40

	_landscape_spriteindexes_3,

    41

};

    42

    43

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

    44

{

    45

	uint load_index_org = load_index;

    46

	uint sprite_id = 0;

    47

    48

	FioOpenFile(file_index, filename);

    49

    50

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

    51

    52

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

    53

		load_index++;

    54

		sprite_id++;

    55

		if (load_index >= MAX_SPRITES) {

    56

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

    57

		}

    58

	}

    59

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

    60

    61

	return load_index - load_index_org;

    62

}

    63

    64

    65

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

    66

{

    67

	uint start;

    68

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

    69

		uint end = *index_tbl++;

    70

    71

		if (start == SKIP) { // skip sprites (amount in second var)

    72

			SkipSprites(end);

    73

			(*sprite_id) += end;

    74

		} else { // load sprites and use indexes from start to end

    75

			do {

    76

			#ifdef NDEBUG

    77

				LoadNextSprite(start, file_index, *sprite_id);

    78

			#else

    79

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

    80

				assert(b);

    81

			#endif

    82

				(*sprite_id)++;

    83

			} while (++start <= end);

    84

		}

    85

	}

    86

}

    87

    88

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

    89

{

    90

	uint sprite_id = 0;

    91

    92

	FioOpenFile(file_index, filename);

    93

    94

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

    95

    96

	LoadSpritesIndexed(file_index, &sprite_id, index_tbl);

    97

}

    98

    99

   100

/**

   101

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

   102

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

   103

 * @return true if the checksum is correct.

   104

 */

   105

static bool FileMD5(const MD5File file)

   106

{

   107

	size_t size;

   108

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

   109

   110

	if (f != NULL) {

   111

		md5_state_t filemd5state;

   112

		md5_byte_t buffer[1024];

   113

		md5_byte_t digest[16];

   114

		size_t len;

   115

   116

		md5_init(&filemd5state);

   117

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

   118

			size -= len;

   119

			md5_append(&filemd5state, buffer, len);

   120

		}

   121

   122

		FioFCloseFile(f);

   123

   124

		md5_finish(&filemd5state, digest);

   125

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

   126

	} else { // file not found

   127

		return false;

   128

	}

   129

}

   130

   131

/**

   132

 * Determine the palette that has to be used.

   133

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

   134

 *  - all Windows files present -> Windows palette

   135

 *  - all DOS files present -> DOS palette

   136

 *  - no Windows files present and any DOS file present -> DOS palette

   137

 *  - otherwise -> Windows palette

   138

 */

   139

static void DeterminePalette()

   140

{

   141

	if (_use_dos_palette) return;

   142

   143

	/* Count of files from the different versions. */

   144

	uint dos = 0;

   145

	uint win = 0;

   146

   147

	for (uint i = 0; i < lengthof(files_dos.basic); i++) if (FioCheckFileExists(files_dos.basic[i].filename)) dos++;

   148

	for (uint i = 0; i < lengthof(files_dos.landscape); i++) if (FioCheckFileExists(files_dos.landscape[i].filename)) dos++;

   149

   150

	for (uint i = 0; i < lengthof(files_win.basic); i++) if (FioCheckFileExists(files_win.basic[i].filename)) win++;

   151

	for (uint i = 0; i < lengthof(files_win.landscape); i++) if (FioCheckFileExists(files_win.landscape[i].filename)) win++;

   152

   153

	if (win == 5) {

   154

		_use_dos_palette = false;

   155

	} else if (dos == 5 || (win == 0 && dos > 0)) {

   156

		_use_dos_palette = true;

   157

	} else {

   158

		_use_dos_palette = false;

   159

	}

   160

}

   161

   162

/**

   163

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

   164

 *

   165

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

   166

 */

   167

void CheckExternalFiles()

   168

{

   169

	DeterminePalette();

   170

   171

	static const size_t ERROR_MESSAGE_LENGTH = 128;

   172

	const FileList *files = _use_dos_palette ? &files_dos : &files_win;

   173

	char error_msg[ERROR_MESSAGE_LENGTH * (lengthof(files->basic) + lengthof(files->landscape) + 3)];

   174

	error_msg[0] = '\0';

   175

	char *add_pos = error_msg;

   176

   177

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

   178

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

   179

			add_pos += snprintf(add_pos, ERROR_MESSAGE_LENGTH, "Your '%s' file is corrupted or missing! You can find '%s' on your Transport Tycoon Deluxe CD-ROM.\n", files->basic[i].filename, files->basic[i].filename);

   180

		}

   181

	}

   182

   183

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

   184

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

   185

			add_pos += snprintf(add_pos, ERROR_MESSAGE_LENGTH, "Your '%s' file is corrupted or missing! You can find '%s' on your Transport Tycoon Deluxe CD-ROM.\n", files->landscape[i].filename, files->landscape[i].filename);

   186

		}

   187

	}

   188

   189

	if (!FileMD5(files_win.sound) && !FileMD5(files_dos.sound)) {

   190

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

   191

	}

   192

   193

	if (!FileMD5(files->chars)) {

   194

		add_pos += snprintf(add_pos, ERROR_MESSAGE_LENGTH, "Your '%s' file is corrupted or missing! The file was part of your installation.\n", files->chars.filename);

   195

	}

   196

   197

	if (!FileMD5(files->openttd)) {

   198

		add_pos += snprintf(add_pos, ERROR_MESSAGE_LENGTH, "Your '%s' file is corrupted or missing! The file was part of your installation.\n", files->openttd.filename);

   199

	}

   200

   201

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

   202

}

   203

   204

   205

static const SpriteID trg1idx[] = {

   206

	   0,    1, ///< Mouse cursor, ZZZ

   207

/* Medium font */

   208

	   2,   92, ///< ' ' till 'z'

   209

	SKIP,   36,

   210

	 160,  160, ///< Move Ÿ to the correct position

   211

	  98,   98, ///< Up arrow

   212

	 131,  133,

   213

	SKIP,    1, ///< skip currency sign

   214

	 135,  135,

   215

	SKIP,    1,

   216

	 137,  137,

   217

	SKIP,    1,

   218

	 139,  139,

   219

	 140,  140, ///< @todo Down arrow

   220

	 141,  141,

   221

	 142,  142, ///< @todo Check mark

   222

	 143,  143, ///< @todo Cross

   223

	 144,  144,

   224

	 145,  145, ///< @todo Right arrow

   225

	 146,  149,

   226

	 118,  122, ///< Transport markers

   227

	SKIP,    2,

   228

	 157,  157,

   229

	 114,  115, ///< Small up/down arrows

   230

	SKIP,    1,

   231

	 161,  225,

   232

/* Small font */

   233

	 226,  316, ///< ' ' till 'z'

   234

	SKIP,   36,

   235

	 384,  384, ///< Move Ÿ to the correct position

   236

	 322,  322, ///< Up arrow

   237

	 355,  357,

   238

	SKIP,    1, ///< skip currency sign

   239

	 359,  359,

   240

	SKIP,    1,

   241

	 361,  361,

   242

	SKIP,    1,

   243

	 363,  363,

   244

	 364,  364, ////< @todo Down arrow

   245

	 365,  366,

   246

	SKIP,    1,

   247

	 368,  368,

   248

	 369,  369, ///< @todo Right arrow

   249

	 370,  373,

   250

	SKIP,    7,

   251

	 381,  381,

   252

	SKIP,    3,

   253

	 385,  449,

   254

/* Big font */

   255

	 450,  540, ///< ' ' till 'z'

   256

	SKIP,   36,

   257

	 608,  608, ///< Move Ÿ to the correct position

   258

	SKIP,    1,

   259

	 579,  581,

   260

	SKIP,    1,

   261

	 583,  583,

   262

	SKIP,    5,

   263

	 589,  589,

   264

	SKIP,   15,

   265

	 605,  605,

   266

	SKIP,    3,

   267

	 609,  625,

   268

	SKIP,    1,

   269

	 627,  632,

   270

	SKIP,    1,

   271

	 634,  639,

   272

	SKIP,    1,

   273

	 641,  657,

   274

	SKIP,    1,

   275

	 659,  664,

   276

	SKIP,    2,

   277

	 667,  671,

   278

	SKIP,    1,

   279

	 673,  673,

   280

/* Graphics */

   281

	 674, 4792,

   282

	END

   283

};

   284

   285

/** Replace some letter sprites with some other letters */

   286

static const SpriteID _chars_grf_indexes[] = {

   287

	134, 134, ///<  euro symbol medium size

   288

	582, 582, ///<  euro symbol large size

   289

	358, 358, ///<  euro symbol tiny

   290

	648, 648, ///<  nordic char: æ

   291

	616, 616, ///<  nordic char: Æ

   292

	666, 666, ///<  nordic char: ø

   293

	634, 634, ///<  nordic char: Ø

   294

	382, 383, ///<  Œ œ tiny

   295

	158, 159, ///<  Œ œ medium

   296

	606, 607, ///<  Œ œ large

   297

	360, 360, ///<  Š tiny

   298

	362, 362, ///<  š tiny

   299

	136, 136, ///<  Š medium

   300

	138, 138, ///<  š medium

   301

	584, 584, ///<  Š large

   302

	586, 586, ///<  š large

   303

	626, 626, ///<  Ð large

   304

	658, 658, ///<  ð large

   305

	374, 374, ///<  Ž tiny

   306

	378, 378, ///<  ž tiny

   307

	150, 150, ///<  Ž medium

   308

	154, 154, ///<  ž medium

   309

	598, 598, ///<  Ž large

   310

	602, 602, ///<  ž large

   311

	640, 640, ///<  Þ large

   312

	672, 672, ///<  þ large

   313

	380, 380, ///<  º tiny

   314

	156, 156, ///<  º medium

   315

	604, 604, ///<  º large

   316

	317, 320, ///<  { | } ~ tiny

   317

	 93,  96, ///<  { | } ~ medium

   318

	541, 544, ///<  { | } ~ large

   319

	585, 585, ///<  § large

   320

	587, 587, ///<  © large

   321

	592, 592, ///<  ® large

   322

	594, 597, ///<  ° ± ² ³ large

   323

	633, 633, ///<  × large

   324

	665, 665, ///<  ÷ large

   325

	377, 377, ///<  · small

   326

	153, 153, ///<  · medium

   327

	601, 601, ///<  · large

   328

	END

   329

};

   330

   331

   332

static void LoadSpriteTables()

   333

{

   334

	const FileList *files = _use_dos_palette ? &files_dos : &files_win;

   335

	uint i = FIRST_GRF_SLOT;

   336

   337

	LoadGrfIndexed(files->basic[0].filename, trg1idx, i++);

   338

	DupSprite(  2, 130); // non-breaking space medium

   339

	DupSprite(226, 354); // non-breaking space tiny

   340

	DupSprite(450, 578); // non-breaking space large

   341

   342

	/*

   343

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

   344

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

   345

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

   346

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

   347

	 */

   348

	LoadGrfFile(files->basic[1].filename, 4793, i++);

   349

   350

	/*

   351

	 * Load additional sprites for climates other than temperate.

   352

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

   353

	 * and the ground sprites.

   354

	 */

   355

	if (_opt.landscape != LT_TEMPERATE) {

   356

		LoadGrfIndexed(

   357

			files->landscape[_opt.landscape - 1].filename,

   358

			_landscape_spriteindexes[_opt.landscape - 1],

   359

			i++

   360

		);

   361

	}

   362

   363

	LoadGrfIndexed(files->chars.filename, _chars_grf_indexes, i++);

   364

   365

	/* Initialize the unicode to sprite mapping table */

   366

	InitializeUnicodeGlyphMap();

   367

   368

	/*

   369

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

   370

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

   371

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

   372

	 */

   373

	GRFConfig *top = _grfconfig;

   374

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

   375

	master->filename = strdup(files->openttd.filename);

   376

	FillGRFDetails(master, false);

   377

	ClrBit(master->flags, GCF_INIT_ONLY);

   378

	master->next = top;

   379

	_grfconfig = master;

   380

   381

	LoadNewGRF(SPR_NEWGRFS_BASE, i);

   382

   383

	/* Free and remove the top element. */

   384

	ClearGRFConfig(&master);

   385

	_grfconfig = top;

   386

}

   387

   388

   389

void GfxLoadSprites()

   390

{

   391

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

   392

   393

	GfxInitSpriteMem();

   394

	LoadSpriteTables();

   395

	GfxInitPalettes();

   396

}