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;

    57

    58

	FioOpenFile(file_index, filename);

    59

    60

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

    61

    63

		load_index++;

    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;

    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);

    90

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

    91

			do {

    92

			#ifdef NDEBUG

    94

			#else

    96

				assert(b);

    97

			#endif

    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

{

   118

   119

	if (f != NULL) {

   120

		md5_state_t filemd5state;

   121

		md5_byte_t buffer[1024];

   122

		md5_byte_t digest[16];

   123

		size_t len;

   124

   125

		md5_init(&filemd5state);

   126

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

   127

			md5_append(&filemd5state, buffer, len);

   128

   130

		fclose(f);

   131

   132

		md5_finish(&filemd5state, digest);

   133

		return CheckMD5Digest(file, digest, warn);

   134

	} else { // file not found

   135

		return false;

   136

	}

   137

}

   138

   139

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

   140

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

   141

 * If neither are found, Windows palette is assumed.

   142

 *

   143

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

   144

void CheckExternalFiles()

   145

{

   146

	uint i;

   147

	/* count of files from this version */

   148

	uint dos = 0;

   149

	uint win = 0;

   150

   151

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

   152

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

   153

   154

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

   155

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

   156

   157

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

   158

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

   159

   160

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

   161

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

   162

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

   163

		}

   164

	}

   165

   166

	/*

   167

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

   168

	 * all Windows files present -> Windows palette

   169

	 * all DOS files present -> DOS palette

   170

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

   171

	 * otherwise -> Windows palette

   172

	 */

   173

	if (_use_dos_palette) {

   174

		return;

   175

	} else if (win == 5) {

   176

		_use_dos_palette = false;

   177

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

   178

		_use_dos_palette = true;

   179

	} else {

   180

		_use_dos_palette = false;

   181

	}

   182

}

   183

   184

   185

static const SpriteID trg1idx[] = {

   186

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

   187

/* Medium font */

   188

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

   189

	SKIP,   36,

   190

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

   191

	  98,   98, ///< Up arrow

   192

	 131,  133,

   193

	SKIP,    1, ///< skip currency sign

   194

	 135,  135,

   195

	SKIP,    1,

   196

	 137,  137,

   197

	SKIP,    1,

   198

	 139,  139,

   199

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

   200

	 141,  141,

   201

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

   202

	 143,  143, ///< @todo Cross

   203

	 144,  144,

   204

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

   205

	 146,  149,

   206

	 118,  122, ///< Transport markers

   207

	SKIP,    2,

   208

	 157,  157,

   209

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

   210

	SKIP,    1,

   211

	 161,  225,

   212

/* Small font */

   213

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

   214

	SKIP,   36,

   215

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

   216

	 322,  322, ///< Up arrow

   217

	 355,  357,

   218

	SKIP,    1, ///< skip currency sign

   219

	 359,  359,

   220

	SKIP,    1,

   221

	 361,  361,

   222

	SKIP,    1,

   223

	 363,  363,

   224

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

   225

	 365,  366,

   226

	SKIP,    1,

   227

	 368,  368,

   228

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

   229

	 370,  373,

   230

	SKIP,    7,

   231

	 381,  381,

   232

	SKIP,    3,

   233

	 385,  449,

   234

/* Big font */

   235

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

   236

	SKIP,   36,

   237

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

   238

	SKIP,    1,

   239

	 579,  581,

   240

	SKIP,    1,

   241

	 583,  583,

   242

	SKIP,    5,

   243

	 589,  589,

   244

	SKIP,   15,

   245

	 605,  605,

   246

	SKIP,    3,

   247

	 609,  625,

   248

	SKIP,    1,

   249

	 627,  632,

   250

	SKIP,    1,

   251

	 634,  639,

   252

	SKIP,    1,

   253

	 641,  657,

   254

	SKIP,    1,

   255

	 659,  664,

   256

	SKIP,    2,

   257

	 667,  671,

   258

	SKIP,    1,

   259

	 673,  673,

   260

/* Graphics */

   261

	 674, 4792,

   262

	END

   263

};

   264

   265

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

   266

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

   267

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

   268

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

   269

 * a maximum use of sprite slots. */

   270

static const SpriteID _openttd_grf_indexes[] = {

   271

	SPR_IMG_AUTORAIL, SPR_CURSOR_WAYPOINT, // icons etc

   272

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

   273

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

   274

	358, 358,  ///<  euro symbol tiny

   275

	SPR_CURSOR_CANAL, SPR_IMG_FASTFORWARD, // more icons

   276

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

   277

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

   278

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

   279

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

   280

	SPR_PIN_UP, SPR_CURSOR_CLONE_TRAIN, // more icons

   281

	382, 383, ///<  Œ œ tiny

   282

	158, 159, ///<  Œ œ medium

   283

	606, 607, ///<  Œ œ large

   284

	360, 360, ///<  Š tiny

   285

	362, 362, ///<  š tiny

   286

	136, 136, ///<  Š medium

   287

	138, 138, ///<  š medium

   288

	584, 584, ///<  Š large

   289

	586, 586, ///<  š large

   290

	626, 626, ///<  Ð large

   291

	658, 658, ///<  ð large

   292

	374, 374, ///<  Ž tiny

   293

	378, 378, ///<  ž tiny

   294

	150, 150, ///<  Ž medium

   295

	154, 154, ///<  ž medium

   296

	598, 598, ///<  Ž large

   297

	602, 602, ///<  ž large

   298

	640, 640, ///<  Þ large

   299

	672, 672, ///<  þ large

   300

	380, 380, ///<  º tiny

   301

	156, 156, ///<  º medium

   302

	604, 604, ///<  º large

   303

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

   304

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

   305

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

   306

	SPR_HOUSE_ICON, SPR_HOUSE_ICON,

   307

	585, 585, ///<  § large

   308

	587, 587, ///<  © large

   309

	592, 592, ///<  ® large

   310

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

   311

	633, 633, ///<  × large

   312

	665, 665, ///<  ÷ large

   313

	SPR_SELL_TRAIN, SPR_SHARED_ORDERS_ICON,

   314

	377, 377, ///<  · small

   315

	153, 153, ///<  · medium

   316

	601, 601, ///<  · large

   317

	SPR_WARNING_SIGN, SPR_WARNING_SIGN,

   318

	END

   319

};

   320

   321

   322

static void LoadSpriteTables()

   323

{

   324

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

   325

	uint load_index;

   326

	uint i;

   327

   328

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

   329

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

   330

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

   331

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

   332

	load_index = 4793;

   333

   334

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

   335

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

   336

	}

   337

   338

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

   339

	if (_opt.landscape != LT_TEMPERATE) {

   340

		LoadGrfIndexed(

   341

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

   342

			_landscape_spriteindexes[_opt.landscape - 1],

   343

			i++

   344

		);

   345

	}

   346

   347

	assert(load_index == SPR_SIGNALS_BASE);

   348

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

   349

   350

	assert(load_index == SPR_CANALS_BASE);

   351

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

   352

   353

	assert(load_index == SPR_SLOPES_BASE);

   354

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

   355

   356

	load_index = SPR_AUTORAIL_BASE;

   357

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

   358

   359

	assert(load_index == SPR_ELRAIL_BASE);

   360

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

   361

   362

	assert(load_index == SPR_2CCMAP_BASE);

   363

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

   364

   365

	assert(load_index == SPR_OPENTTD_BASE);

   366

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

   367

	load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT;

   368

   369

	assert(load_index == SPR_AIRPORTX_BASE);

   370

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

   371

   372

	assert(load_index == SPR_ROADSTOP_BASE);

   373

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

   374

   375

	assert(load_index == SPR_GROUP_BASE);

   376

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

   377

   378

	assert(load_index == SPR_TRAMWAY_BASE);

   379

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

   380

   381

	assert(load_index == SPR_ONEWAY_BASE);

   382

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

   383

   384

	assert(load_index == SPR_FLAGS_BASE);

   385

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

   386

   387

	/* Initialize the unicode to sprite mapping table */

   388

	InitializeUnicodeGlyphMap();

   389

   390

	LoadNewGRF(load_index, i);

   391

}

   392

   393

   394

void GfxLoadSprites()

   395

{

   396

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

   397

   398

	GfxInitSpriteMem();

   399

	LoadSpriteTables();

   400

	GfxInitPalettes();

   401

}