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

    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[4];          ///< grf files that always have to be loaded

    28

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

    29

};

    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

	uint sprite_id = 0;

    57

    58

	FioOpenFile(file_index, filename);

    59

    60

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

    61

    62

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

    63

		load_index++;

    64

		sprite_id++;

    65

		if (load_index >= MAX_SPRITES) {

    66

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

    67

		}

    68

	}

    69

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

    70

    71

	return load_index - load_index_org;

    72

}

    73

    74

    75

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

    76

{

    77

	uint start;

    78

	uint sprite_id = 0;

    79

    80

	FioOpenFile(file_index, filename);

    81

    82

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

    83

    84

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

    85

		uint end = *index_tbl++;

    86

    87

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

    88

			SkipSprites(end);

    89

			sprite_id += end;

    90

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

    91

			do {

    92

			#ifdef NDEBUG

    93

				LoadNextSprite(start, file_index, sprite_id);

    94

			#else

    95

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

    96

				assert(b);

    97

			#endif

    98

				sprite_id++;

    99

			} while (++start <= end);

   100

		}

   101

	}

   102

}

   103

   104

   105

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

   106

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

   107

{

   108

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

   109

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

   110

	return false;

   111

}

   112

   113

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

   114

 * returns true if the checksum is correct */

   115

static bool FileMD5(const MD5File file, bool warn)

   116

{

   117

	size_t size;

   118

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

   119

   120

	if (f != NULL) {

   121

		md5_state_t filemd5state;

   122

		md5_byte_t buffer[1024];

   123

		md5_byte_t digest[16];

   124

		size_t len;

   125

   126

		md5_init(&filemd5state);

   127

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

   128

			size -= len;

   129

			md5_append(&filemd5state, buffer, len);

   130

		}

   131

   132

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

   133

		FioFCloseFile(f);

   134

   135

		md5_finish(&filemd5state, digest);

   136

		return CheckMD5Digest(file, digest, warn);

   137

	} else { // file not found

   138

		return false;

   139

	}

   140

}

   141

   142

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

   143

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

   144

 * If neither are found, Windows palette is assumed.

   145

 *

   146

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

   147

void CheckExternalFiles()

   148

{

   149

	uint i;

   150

	/* count of files from this version */

   151

	uint dos = 0;

   152

	uint win = 0;

   153

   154

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

   155

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

   156

   157

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

   158

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

   159

   160

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

   161

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

   162

   163

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

   164

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

   165

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

   166

		}

   167

	}

   168

   169

	/*

   170

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

   171

	 * all Windows files present -> Windows palette

   172

	 * all DOS files present -> DOS palette

   173

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

   174

	 * otherwise -> Windows palette

   175

	 */

   176

	if (_use_dos_palette) {

   177

		return;

   178

	} else if (win == 5) {

   179

		_use_dos_palette = false;

   180

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

   181

		_use_dos_palette = true;

   182

	} else {

   183

		_use_dos_palette = false;

   184

	}

   185

}

   186

   187

   188

static const SpriteID trg1idx[] = {

   189

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

   190

/* Medium font */

   191

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

   192

	SKIP,   36,

   193

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

   194

	  98,   98, ///< Up arrow

   195

	 131,  133,

   196

	SKIP,    1, ///< skip currency sign

   197

	 135,  135,

   198

	SKIP,    1,

   199

	 137,  137,

   200

	SKIP,    1,

   201

	 139,  139,

   202

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

   203

	 141,  141,

   204

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

   205

	 143,  143, ///< @todo Cross

   206

	 144,  144,

   207

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

   208

	 146,  149,

   209

	 118,  122, ///< Transport markers

   210

	SKIP,    2,

   211

	 157,  157,

   212

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

   213

	SKIP,    1,

   214

	 161,  225,

   215

/* Small font */

   216

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

   217

	SKIP,   36,

   218

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

   219

	 322,  322, ///< Up arrow

   220

	 355,  357,

   221

	SKIP,    1, ///< skip currency sign

   222

	 359,  359,

   223

	SKIP,    1,

   224

	 361,  361,

   225

	SKIP,    1,

   226

	 363,  363,

   227

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

   228

	 365,  366,

   229

	SKIP,    1,

   230

	 368,  368,

   231

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

   232

	 370,  373,

   233

	SKIP,    7,

   234

	 381,  381,

   235

	SKIP,    3,

   236

	 385,  449,

   237

/* Big font */

   238

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

   239

	SKIP,   36,

   240

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

   241

	SKIP,    1,

   242

	 579,  581,

   243

	SKIP,    1,

   244

	 583,  583,

   245

	SKIP,    5,

   246

	 589,  589,

   247

	SKIP,   15,

   248

	 605,  605,

   249

	SKIP,    3,

   250

	 609,  625,

   251

	SKIP,    1,

   252

	 627,  632,

   253

	SKIP,    1,

   254

	 634,  639,

   255

	SKIP,    1,

   256

	 641,  657,

   257

	SKIP,    1,

   258

	 659,  664,

   259

	SKIP,    2,

   260

	 667,  671,

   261

	SKIP,    1,

   262

	 673,  673,

   263

/* Graphics */

   264

	 674, 4792,

   265

	END

   266

};

   267

   268

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

   269

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

   270

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

   271

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

   272

 * a maximum use of sprite slots. */

   273

static const SpriteID _openttd_grf_indexes[] = {

   274

	SPR_IMG_AUTORAIL, SPR_CURSOR_WAYPOINT, // icons etc

   275

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

   276

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

   277

	358, 358,  ///<  euro symbol tiny

   278

	SPR_CURSOR_CANAL, SPR_IMG_FASTFORWARD, // more icons

   279

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

   280

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

   281

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

   282

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

   283

	SPR_PIN_UP, SPR_CURSOR_CLONE_TRAIN, // more icons

   284

	382, 383, ///<  Œ œ tiny

   285

	158, 159, ///<  Œ œ medium

   286

	606, 607, ///<  Œ œ large

   287

	360, 360, ///<  Š tiny

   288

	362, 362, ///<  š tiny

   289

	136, 136, ///<  Š medium

   290

	138, 138, ///<  š medium

   291

	584, 584, ///<  Š large

   292

	586, 586, ///<  š large

   293

	626, 626, ///<  Ð large

   294

	658, 658, ///<  ð large

   295

	374, 374, ///<  Ž tiny

   296

	378, 378, ///<  ž tiny

   297

	150, 150, ///<  Ž medium

   298

	154, 154, ///<  ž medium

   299

	598, 598, ///<  Ž large

   300

	602, 602, ///<  ž large

   301

	640, 640, ///<  Þ large

   302

	672, 672, ///<  þ large

   303

	380, 380, ///<  º tiny

   304

	156, 156, ///<  º medium

   305

	604, 604, ///<  º large

   306

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

   307

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

   308

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

   309

	SPR_HOUSE_ICON, SPR_HOUSE_ICON,

   310

	585, 585, ///<  § large

   311

	587, 587, ///<  © large

   312

	592, 592, ///<  ® large

   313

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

   314

	633, 633, ///<  × large

   315

	665, 665, ///<  ÷ large

   316

	SPR_SELL_TRAIN, SPR_SHARED_ORDERS_ICON,

   317

	377, 377, ///<  · small

   318

	153, 153, ///<  · medium

   319

	601, 601, ///<  · large

   320

	SPR_WARNING_SIGN, SPR_WARNING_SIGN,

   321

	END

   322

};

   323

   324

   325

static void LoadSpriteTables()

   326

{

   327

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

   328

	uint load_index;

   329

	uint i;

   330

   331

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

   332

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

   333

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

   334

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

   335

	load_index = 4793;

   336

   337

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

   338

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

   339

	}

   340

   341

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

   342

	if (_opt.landscape != LT_TEMPERATE) {

   343

		LoadGrfIndexed(

   344

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

   345

			_landscape_spriteindexes[_opt.landscape - 1],

   346

			i++

   347

		);

   348

	}

   349

   350

	assert(load_index == SPR_SIGNALS_BASE);

   351

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

   352

   353

	assert(load_index == SPR_CANALS_BASE);

   354

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

   355

   356

	assert(load_index == SPR_SLOPES_BASE);

   357

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

   358

   359

	load_index = SPR_AUTORAIL_BASE;

   360

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

   361

   362

	assert(load_index == SPR_ELRAIL_BASE);

   363

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

   364

   365

	assert(load_index == SPR_2CCMAP_BASE);

   366

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

   367

   368

	assert(load_index == SPR_OPENTTD_BASE);

   369

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

   370

	load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT;

   371

   372

	assert(load_index == SPR_AIRPORTX_BASE);

   373

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

   374

   375

	assert(load_index == SPR_ROADSTOP_BASE);

   376

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

   377

   378

	assert(load_index == SPR_GROUP_BASE);

   379

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

   380

   381

	assert(load_index == SPR_TRAMWAY_BASE);

   382

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

   383

   384

	assert(load_index == SPR_ONEWAY_BASE);

   385

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

   386

   389

	assert(load_index == SPR_FLAGS_BASE);

   390

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

   391

   392

	/* Initialize the unicode to sprite mapping table */

   393

	InitializeUnicodeGlyphMap();

   394

   395

	LoadNewGRF(load_index, i);

   396

}

   397

   398

   399

void GfxLoadSprites()

   400

{

   401

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

   402

   403

	GfxInitSpriteMem();

   404

	LoadSpriteTables();

   405

	GfxInitPalettes();

   406

}