1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "gfx.h"

     8

#include "gfxinit.h"

     9

#include "spritecache.h"

    10

#include "table/sprites.h"

    11

#include "fileio.h"

    12

#include "string.h"

    13

#include "newgrf.h"

    14

#include "md5.h"

    15

#include "variables.h"

    16

    17

typedef struct MD5File {

    18

	const char * const filename;     // filename

    19

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

    20

} MD5File;

    21

    22

typedef struct FileList {

    23

	const MD5File basic[5];     // grf files that always have to be loaded

    24

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

    25

} FileList;

    26

    27

enum {

    28

	SKIP = 0xFFFE,

    29

	END  = 0xFFFF

    30

};

    31

    32

#include "table/files.h"

    33

#include "table/landscape_sprite.h"

    34

    35

static const SpriteID * const _landscape_spriteindexes[] = {

    36

	_landscape_spriteindexes_1,

    37

	_landscape_spriteindexes_2,

    38

	_landscape_spriteindexes_3,

    39

};

    40

    41

static const SpriteID * const _slopes_spriteindexes[] = {

    42

	_slopes_spriteindexes_0,

    43

	_slopes_spriteindexes_1,

    44

	_slopes_spriteindexes_2,

    45

	_slopes_spriteindexes_3,

    46

};

    47

    48

    49

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

    50

{

    51

	uint load_index_org = load_index;

    52

    53

	FioOpenFile(file_index, filename);

    54

    55

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

    56

    57

	while (LoadNextSprite(load_index, file_index)) {

    58

		load_index++;

    59

		if (load_index >= MAX_SPRITES) {

    60

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

    61

		}

    62

	}

    63

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

    64

    65

	return load_index - load_index_org;

    66

}

    67

    68

    69

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

    70

{

    71

	uint start;

    72

    73

	FioOpenFile(file_index, filename);

    74

    75

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

    76

    77

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

    78

		uint end = *index_tbl++;

    79

    80

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

    81

			SkipSprites(end);

    82

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

    83

			do {

    84

			#ifdef NDEBUG

    85

				LoadNextSprite(start, file_index);

    86

			#else

    87

				bool b = LoadNextSprite(start, file_index);

    88

				assert(b);

    89

			#endif

    90

			} while (++start <= end);

    91

		}

    92

	}

    93

}

    94

    95

    96

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

    97

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

    98

{

    99

	uint i;

   100

   101

	/* Loop through each byte of the file MD5 and the stored MD5... */

   102

	for (i = 0; i < 16; i++) if (file.hash[i] != digest[i]) break;

   103

   104

		/* If all bytes of the MD5's match (i.e. the MD5's match)... */

   105

	if (i == 16) {

   106

		return true;

   107

	} else {

   108

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

   109

		return false;

   110

	};

   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

	FILE *f;

   118

	char buf[MAX_PATH];

   119

   120

	// open file

   121

	sprintf(buf, "%s%s", _path.data_dir, file.filename);

   122

	f = fopen(buf, "rb");

   123

   124

#if !defined(WIN32)

   125

	if (f == NULL) {

   126

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

   127

		f = fopen(buf, "rb");

   128

	}

   129

#endif

   130

   131

	if (f != NULL) {

   132

		md5_state_t filemd5state;

   133

		md5_byte_t buffer[1024];

   134

		md5_byte_t digest[16];

   135

		size_t len;

   136

   137

		md5_init(&filemd5state);

   138

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

   139

			md5_append(&filemd5state, buffer, len);

   140

   141

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

   142

		fclose(f);

   143

   144

		md5_finish(&filemd5state, digest);

   145

		return CheckMD5Digest(file, digest, warn);

   146

	} else { // file not found

   147

		return false;

   148

	}

   149

}

   150

   151

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

   152

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

   153

 * If neither are found, Windows palette is assumed.

   154

 *

   155

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

   156

void CheckExternalFiles(void)

   157

{

   158

	uint i;

   159

	// count of files from this version

   160

	uint dos = 0;

   161

	uint win = 0;

   162

   163

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

   164

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

   165

   166

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

   167

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

   168

   169

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

   170

		fprintf(stderr, "Your sample.cat file is corrupted or missing!\n");

   171

   172

	/*

   173

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

   174

	 * all Windows files present -> Windows palette

   175

	 * all DOS files present -> DOS palette

   176

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

   177

	 * otherwise -> Windows palette

   178

	 */

   179

	if (_use_dos_palette) {

   180

		return;

   181

	} else if (win == 5) {

   182

		_use_dos_palette = false;

   183

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

   184

		_use_dos_palette = true;

   185

	} else {

   186

		_use_dos_palette = false;

   187

	}

   188

}

   189

   190

   191

static const SpriteID trg1idx[] = {

   192

	   0,    1, // Mouse cursor, ZZZ

   193

/* Medium font */

   194

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

   195

	SKIP,   36,

   196

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

   197

	  98,   98, // Up arrow

   198

	 131,  133,

   199

	SKIP,    1, // skip currency sign

   200

	 135,  135,

   201

	SKIP,    1,

   202

	 137,  137,

   203

	SKIP,    1,

   204

	 139,  139,

   205

	 140,  140, // TODO Down arrow

   206

	 141,  141,

   207

	 142,  142, // TODO Check mark

   208

	 143,  143, // TODO Cross

   209

	 144,  144,

   210

	 145,  145, // TODO Right arrow

   211

	 146,  149,

   212

	 118,  122, // Transport markers

   213

	SKIP,    2,

   214

	 157,  157,

   215

	 114,  115, // Small up/down arrows

   216

	SKIP,    1,

   217

	 161,  225,

   218

/* Small font */

   219

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

   220

	SKIP,   36,

   221

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

   222

	 322,  322, // Up arrow

   223

	 355,  357,

   224

	SKIP,    1, // skip currency sign

   225

	 359,  359,

   226

	SKIP,    1,

   227

	 361,  361,

   228

	SKIP,    1,

   229

	 363,  363,

   230

	 364,  364, // TODO Down arrow

   231

	 365,  366,

   232

	SKIP,    1,

   233

	 368,  368,

   234

	 369,  369, // TODO Right arrow

   235

	 370,  373,

   236

	SKIP,    7,

   237

	 381,  381,

   238

	SKIP,    3,

   239

	 385,  449,

   240

/* Big font */

   241

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

   242

	SKIP,   36,

   243

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

   244

	SKIP,    1,

   245

	 579,  581,

   246

	SKIP,    1,

   247

	 583,  583,

   248

	SKIP,    5,

   249

	 589,  589,

   250

	SKIP,   15,

   251

	 605,  605,

   252

	SKIP,    3,

   253

	 609,  625,

   254

	SKIP,    1,

   255

	 627,  632,

   256

	SKIP,    1,

   257

	 634,  639,

   258

	SKIP,    1,

   259

	 641,  657,

   260

	SKIP,    1,

   261

	 659,  664,

   262

	SKIP,    2,

   263

	 667,  671,

   264

	SKIP,    1,

   265

	 673,  673,

   266

/* Graphics */

   267

	 674, 4792,

   268

	END

   269

};

   270

   271

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

   272

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

   273

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

   274

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

   275

 * a maximum use of sprite slots. */

   276

#define OPENTTD_SPRITES_COUNT 95

   277

static const SpriteID _openttd_grf_indexes[] = {

   278

	SPR_IMG_AUTORAIL, SPR_CURSOR_WAYPOINT, // icons etc

   279

	134, 134,  // euro symbol medium size

   280

	582, 582,  // euro symbol large size

   281

	358, 358,  // euro symbol tiny

   282

	SPR_CURSOR_CANAL, SPR_IMG_FASTFORWARD, // more icons

   283

	648, 648, // nordic char: æ

   284

	616, 616, // nordic char: Æ

   285

	666, 666, // nordic char: ø

   286

	634, 634, // nordic char: Ø

   287

	SPR_PIN_UP, SPR_CURSOR_CLONE, // more icons

   288

	382, 383, // ¼ ½ tiny

   289

	158, 159, // ¼ ½ medium

   290

	606, 607, // ¼ ½ large

   291

	360, 360, // ¦ tiny

   292

	362, 362, // ¨ tiny

   293

	136, 136, // ¦ medium

   294

	138, 138, // ¨ medium

   295

	584, 584, // ¦ large

   296

	586, 586, // ¨ large

   297

	626, 626, // Ð large

   298

	658, 658, // ð large

   299

	374, 374, // ´ tiny

   300

	378, 378, // ¸ tiny

   301

	150, 150, // ´ medium

   302

	154, 154, // ¸ medium

   303

	598, 598, // ´ large

   304

	602, 602, // ¸ large

   305

	640, 640, // Þ large

   306

	672, 672, // þ large

   307

	380, 380, // º tiny

   308

	156, 156, // º medium

   309

	604, 604, // º large

   310

	317, 320, // { | } ~ tiny

   311

	 93,  96, // { | } ~ medium

   312

	541, 544, // { | } ~ large

   313

	SPR_HOUSE_ICON, SPR_HOUSE_ICON,

   314

	585, 585, // § large

   315

	587, 587, // © large

   316

	592, 592, // ® large

   317

	594, 597, // ° ± ² ³ large

   318

	633, 633, // × large

   319

	665, 665, // ÷ large

   320

	END

   321

};

   322

   323

static byte _sprite_page_to_load = 0xFF;

   324

   325

static void LoadSpriteTables(void)

   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

	if (_sprite_page_to_load != 0) {

   342

		LoadGrfIndexed(

   343

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

   344

			_landscape_spriteindexes[_sprite_page_to_load - 1],

   345

			i++

   346

		);

   347

	}

   348

   349

	assert(load_index == SPR_CANALS_BASE);

   350

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

   351

   352

	assert(load_index == SPR_SLOPES_BASE);

   353

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

   354

   355

	load_index = SPR_AUTORAIL_BASE;

   356

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

   357

   358

	assert(load_index == SPR_ELRAIL_BASE);

   359

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

   360

   361

	assert(load_index == SPR_2CCMAP_BASE);

   362

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

   363

   364

	assert(load_index == SPR_OPENTTD_BASE);

   365

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

   366

	load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT;

   367

   368

	assert(load_index == SPR_AIRPORTX_BASE);

   369

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

   370

   371

	LoadNewGRF(load_index, i);

   372

}

   373

   374

   375

void GfxLoadSprites(void)

   376

{

   377

	// Need to reload the sprites only if the landscape changed

   378

	if (_sprite_page_to_load != _opt.landscape) {

   379

		_sprite_page_to_load = _opt.landscape;

   380

   381

		// Sprite cache

   382

		DEBUG(spritecache, 1) ("Loading sprite set %d.", _sprite_page_to_load);

   383

   384

		GfxInitSpriteMem();

   385

		LoadSpriteTables();

   386

		GfxInitPalettes();

   387

	}

   388

}