1

/* $Id$ */

     2

     3

/** @file gfxinit.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "functions.h"

     9

#include "gfx.h"

    10

#include "gfxinit.h"

    11

#include "spritecache.h"

    12

#include "table/sprites.h"

    13

#include "fileio.h"

    14

#include "string.h"

    15

#include "newgrf.h"

    16

#include "md5.h"

    17

#include "variables.h"

    18

#include "fontcache.h"

    19

#include <string.h>

    20

    22

	const char * filename;     ///< filename

    23

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

    25

    27

	MD5File basic[4];          ///< grf files that always have to be loaded

    28

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

    30

    31

enum {

    32

	SKIP = 0xFFFE,

    33

	END  = 0xFFFF

    34

};

    35

    36

#include "table/files.h"

    37

#include "table/landscape_sprite.h"

    38

    39

static const SpriteID * const _landscape_spriteindexes[] = {

    40

	_landscape_spriteindexes_1,

    41

	_landscape_spriteindexes_2,

    42

	_landscape_spriteindexes_3,

    43

};

    44

    45

static const SpriteID * const _slopes_spriteindexes[] = {

    46

	_slopes_spriteindexes_0,

    47

	_slopes_spriteindexes_1,

    48

	_slopes_spriteindexes_2,

    49

	_slopes_spriteindexes_3,

    50

};

    51

    52

    53

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

    54

{

    55

	uint load_index_org = load_index;

    56

    57

	FioOpenFile(file_index, filename);

    58

    59

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

    60

    61

	while (LoadNextSprite(load_index, file_index)) {

    62

		load_index++;

    63

		if (load_index >= MAX_SPRITES) {

    64

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

    65

		}

    66

	}

    67

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

    68

    69

	return load_index - load_index_org;

    70

}

    71

    72

    73

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

    74

{

    75

	uint start;

    76

    77

	FioOpenFile(file_index, filename);

    78

    79

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

    80

    81

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

    82

		uint end = *index_tbl++;

    83

    84

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

    85

			SkipSprites(end);

    86

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

    87

			do {

    88

			#ifdef NDEBUG

    89

				LoadNextSprite(start, file_index);

    90

			#else

    91

				bool b = LoadNextSprite(start, file_index);

    92

				assert(b);

    93

			#endif

    94

			} while (++start <= end);

    95

		}

    96

	}

    97

}

    98

    99

   100

/* Check that the supplied MD5 hash matches that stored for the supplied filename */

   101

static bool CheckMD5Digest(const MD5File file, md5_byte_t *digest, bool warn)

   102

{

   103

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

   104

	if (warn) fprintf(stderr, "MD5 of %s is ****INCORRECT**** - File Corrupt.\n", file.filename);

   105

	return false;

   106

}

   107

   108

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

   109

 * returns true if the checksum is correct */

   110

static bool FileMD5(const MD5File file, bool warn)

   111

{

   112

	FILE *f;

   113

	char buf[MAX_PATH];

   114

   115

	/* open file */

   116

	snprintf(buf, lengthof(buf), "%s%s", _paths.data_dir, file.filename);

   117

	f = fopen(buf, "rb");

   118

   119

#if !defined(WIN32)

   120

	if (f == NULL) {

   121

		strtolower(buf + strlen(_paths.data_dir) - 1);

   122

		f = fopen(buf, "rb");

   123

	}

   124

#endif

   125

   126

#if defined SECOND_DATA_DIR

   127

	/* If we failed to find the file in the first data directory, we will try the other one */

   128

   129

	if (f == NULL) {

   130

		snprintf(buf, lengthof(buf), "%s%s", _paths.second_data_dir, file.filename);

   131

		f = fopen(buf, "rb");

   132

   133

		if (f == NULL) {

   134

			strtolower(buf + strlen(_paths.second_data_dir) - 1);

   135

			f = fopen(buf, "rb");

   136

		}

   137

	}

   138

#endif

   139

   140

	if (f != NULL) {

   141

		md5_state_t filemd5state;

   142

		md5_byte_t buffer[1024];

   143

		md5_byte_t digest[16];

   144

		size_t len;

   145

   146

		md5_init(&filemd5state);

   147

		while ((len = fread(buffer, 1, sizeof(buffer), f)) != 0)

   148

			md5_append(&filemd5state, buffer, len);

   149

   150

		if (ferror(f) && warn) ShowInfoF("Error Reading from %s \n", buf);

   151

		fclose(f);

   152

   153

		md5_finish(&filemd5state, digest);

   154

		return CheckMD5Digest(file, digest, warn);

   155

	} else { // file not found

   156

		return false;

   157

	}

   158

}

   159

   160

/* Checks, if either the Windows files exist (TRG1R.GRF) or the DOS files (TRG1.GRF)

   161

 * by comparing the MD5 checksums of the files. _use_dos_palette is set accordingly.

   162

 * If neither are found, Windows palette is assumed.

   163

 *

   164

 * (Note: Also checks sample.cat for corruption) */

   165

void CheckExternalFiles()

   166

{

   167

	uint i;

   168

	/* count of files from this version */

   169

	uint dos = 0;

   170

	uint win = 0;

   171

   172

	for (i = 0; i < 2; i++) if (FileMD5(files_dos.basic[i], true)) dos++;

   173

	for (i = 0; i < 3; i++) if (FileMD5(files_dos.landscape[i], true)) dos++;

   174

   175

	for (i = 0; i < 2; i++) if (FileMD5(files_win.basic[i], true)) win++;

   176

	for (i = 0; i < 3; i++) if (FileMD5(files_win.landscape[i], true)) win++;

   177

   178

	if (!FileMD5(sample_cat_win, false) && !FileMD5(sample_cat_dos, false))

   179

		ShowInfo("Your 'sample.cat' file is corrupted or missing!");

   180

   181

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

   182

		if (!FileMD5(files_openttd[i], false)) {

   183

			ShowInfoF("Your '%s' file is corrupted or missing!", files_openttd[i].filename);

   184

		}

   185

	}

   186

   187

	/*

   188

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

   189

	 * all Windows files present -> Windows palette

   190

	 * all DOS files present -> DOS palette

   191

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

   192

	 * otherwise -> Windows palette

   193

	 */

   194

	if (_use_dos_palette) {

   195

		return;

   196

	} else if (win == 5) {

   197

		_use_dos_palette = false;

   198

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

   199

		_use_dos_palette = true;

   200

	} else {

   201

		_use_dos_palette = false;

   202

	}

   203

}

   204

   205

   206

static const SpriteID trg1idx[] = {

   207

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

   208

/* Medium font */

   209

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

   210

	SKIP,   36,

   211

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

   212

	  98,   98, ///< Up arrow

   213

	 131,  133,

   214

	SKIP,    1, ///< skip currency sign

   215

	 135,  135,

   216

	SKIP,    1,

   217

	 137,  137,

   218

	SKIP,    1,

   219

	 139,  139,

   220

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

   221

	 141,  141,

   222

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

   223

	 143,  143, ///< @todo Cross

   224

	 144,  144,

   225

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

   226

	 146,  149,

   227

	 118,  122, ///< Transport markers

   228

	SKIP,    2,

   229

	 157,  157,

   230

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

   231

	SKIP,    1,

   232

	 161,  225,

   233

/* Small font */

   234

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

   235

	SKIP,   36,

   236

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

   237

	 322,  322, ///< Up arrow

   238

	 355,  357,

   239

	SKIP,    1, ///< skip currency sign

   240

	 359,  359,

   241

	SKIP,    1,

   242

	 361,  361,

   243

	SKIP,    1,

   244

	 363,  363,

   245

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

   246

	 365,  366,

   247

	SKIP,    1,

   248

	 368,  368,

   249

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

   250

	 370,  373,

   251

	SKIP,    7,

   252

	 381,  381,

   253

	SKIP,    3,

   254

	 385,  449,

   255

/* Big font */

   256

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

   257

	SKIP,   36,

   258

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

   259

	SKIP,    1,

   260

	 579,  581,

   261

	SKIP,    1,

   262

	 583,  583,

   263

	SKIP,    5,

   264

	 589,  589,

   265

	SKIP,   15,

   266

	 605,  605,

   267

	SKIP,    3,

   268

	 609,  625,

   269

	SKIP,    1,

   270

	 627,  632,

   271

	SKIP,    1,

   272

	 634,  639,

   273

	SKIP,    1,

   274

	 641,  657,

   275

	SKIP,    1,

   276

	 659,  664,

   277

	SKIP,    2,

   278

	 667,  671,

   279

	SKIP,    1,

   280

	 673,  673,

   281

/* Graphics */

   282

	 674, 4792,

   283

	END

   284

};

   285

   286

/* NOTE: When adding a normal sprite, increase OPENTTD_SPRITES_COUNT with the

   287

 * amount of sprites and add them to the end of the list, with the index of

   288

 * the old sprite-count offset from SPR_OPENTTD_BASE. With this there is no

   289

 * correspondence of any kind with the ID's in the grf file, but results in

   290

 * a maximum use of sprite slots. */

   291

static const SpriteID _openttd_grf_indexes[] = {

   292

	SPR_IMG_AUTORAIL, SPR_CURSOR_WAYPOINT, // icons etc

   293

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

   294

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

   295

	358, 358,  ///<  euro symbol tiny

   296

	SPR_CURSOR_CANAL, SPR_IMG_FASTFORWARD, // more icons

   297

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

   298

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

   299

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

   300

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

   301

	SPR_PIN_UP, SPR_CURSOR_CLONE_TRAIN, // more icons

   302

	382, 383, ///<  ¼ ½ tiny

   303

	158, 159, ///<  ¼ ½ medium

   304

	606, 607, ///<  ¼ ½ large

   305

	360, 360, ///<  ¦ tiny

   306

	362, 362, ///<  ¨ tiny

   307

	136, 136, ///<  ¦ medium

   308

	138, 138, ///<  ¨ medium

   309

	584, 584, ///<  ¦ large

   310

	586, 586, ///<  ¨ large

   311

	626, 626, ///<  Ð large

   312

	658, 658, ///<  ð large

   313

	374, 374, ///<  ´ tiny

   314

	378, 378, ///<  ¸ tiny

   315

	150, 150, ///<  ´ medium

   316

	154, 154, ///<  ¸ medium

   317

	598, 598, ///<  ´ large

   318

	602, 602, ///<  ¸ large

   319

	640, 640, ///<  Þ large

   320

	672, 672, ///<  þ large

   321

	380, 380, ///<  º tiny

   322

	156, 156, ///<  º medium

   323

	604, 604, ///<  º large

   324

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

   325

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

   326

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

   327

	SPR_HOUSE_ICON, SPR_HOUSE_ICON,

   328

	585, 585, ///<  § large

   329

	587, 587, ///<  © large

   330

	592, 592, ///<  ® large

   331

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

   332

	633, 633, ///<  × large

   333

	665, 665, ///<  ÷ large

   334

	SPR_SELL_TRAIN, SPR_SHARED_ORDERS_ICON,

   335

	377, 377, ///<  · small

   336

	153, 153, ///<  · medium

   337

	601, 601, ///<  · large

   338

	SPR_WARNING_SIGN, SPR_WARNING_SIGN,

   339

	END

   340

};

   341

   342

   343

static void LoadSpriteTables()

   344

{

   345

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

   346

	uint load_index;

   347

	uint i;

   348

   349

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

   350

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

   351

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

   352

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

   353

	load_index = 4793;

   354

   355

	for (i = 1; files->basic[i].filename != NULL; i++) {

   356

		load_index += LoadGrfFile(files->basic[i].filename, load_index, i);

   357

	}

   358

   359

	/* Load additional sprites for climates other than temperate */

   360

	if (_opt.landscape != LT_NORMAL) {

   361

		LoadGrfIndexed(

   362

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

   363

			_landscape_spriteindexes[_opt.landscape - 1],

   364

			i++

   365

		);

   366

	}

   367

   368

	assert(load_index == SPR_SIGNALS_BASE);

   369

	load_index += LoadGrfFile("nsignalsw.grf", load_index, i++);

   370

   371

	assert(load_index == SPR_CANALS_BASE);

   372

	load_index += LoadGrfFile("canalsw.grf", load_index, i++);

   373

   374

	assert(load_index == SPR_SLOPES_BASE);

   375

	LoadGrfIndexed("trkfoundw.grf", _slopes_spriteindexes[_opt.landscape], i++);

   376

   377

	load_index = SPR_AUTORAIL_BASE;

   378

	load_index += LoadGrfFile("autorail.grf", load_index, i++);

   379

   380

	assert(load_index == SPR_ELRAIL_BASE);

   381

	load_index += LoadGrfFile("elrailsw.grf", load_index, i++);

   382

   383

	assert(load_index == SPR_2CCMAP_BASE);

   384

	load_index += LoadGrfFile("2ccmap.grf", load_index, i++);

   385

   386

	assert(load_index == SPR_OPENTTD_BASE);

   387

	LoadGrfIndexed("openttd.grf", _openttd_grf_indexes, i++);

   388

	load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT;

   389

   390

	assert(load_index == SPR_AIRPORTX_BASE);

   391

	load_index += LoadGrfFile("airports.grf", load_index, i++);

   392

   393

	assert(load_index == SPR_ROADSTOP_BASE);

   394

	load_index += LoadGrfFile("roadstops.grf", load_index, i++);

   395

   396

	/* Initialize the unicode to sprite mapping table */

   397

	InitializeUnicodeGlyphMap();

   398

   399

	LoadNewGRF(load_index, i);

   400

}

   401

   402

   403

void GfxLoadSprites()

   404

{

   405

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

   406

   407

	GfxInitSpriteMem();

   408

	LoadSpriteTables();

   409

	GfxInitPalettes();

   410

}