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 "newgrf.h"

    13

#include "md5.h"

    14

#include "variables.h"

    15

#include <ctype.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

		char *s;

   127

	// make lower case and check again

   128

		for (s = buf + strlen(_path.data_dir) - 1; *s != '\0'; s++)

   129

			*s = tolower(*s);

   130

		f = fopen(buf, "rb");

   131

	}

   132

#endif

   133

   134

	if (f != NULL) {

   135

		md5_state_t filemd5state;

   136

		md5_byte_t buffer[1024];

   137

		md5_byte_t digest[16];

   138

		size_t len;

   139

   140

		md5_init(&filemd5state);

   141

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

   142

			md5_append(&filemd5state, buffer, len);

   143

   144

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

   145

		fclose(f);

   146

   147

		md5_finish(&filemd5state, digest);

   148

		return CheckMD5Digest(file, digest, warn);

   149

	} else { // file not found

   150

		return false;

   151

	}

   152

}

   153

   154

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

   155

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

   156

 * If neither are found, Windows palette is assumed.

   157

 *

   158

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

   159

void CheckExternalFiles(void)

   160

{

   161

	uint i;

   162

	// count of files from this version

   163

	uint dos = 0;

   164

	uint win = 0;

   165

   166

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

   167

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

   168

   169

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

   170

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

   171

   172

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

   173

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

   174

   175

	/*

   176

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

   177

	 * all Windows files present -> Windows palette

   178

	 * all DOS files present -> DOS palette

   179

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

   180

	 * otherwise -> Windows palette

   181

	 */

   182

	if (_use_dos_palette) {

   183

		return;

   184

	} else if (win == 5) {

   185

		_use_dos_palette = false;

   186

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

   187

		_use_dos_palette = true;

   188

	} else {

   189

		_use_dos_palette = false;

   190

	}

   191

}

   192

   193

   194

static const SpriteID trg1idx[] = {

   195

	   0,    1, // Mouse cursor, ZZZ

   196

/* Medium font */

   197

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

   198

	SKIP,   36,

   199

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

   200

	  98,   98, // Up arrow

   201

	 131,  133,

   202

	SKIP,    1, // skip currency sign

   203

	 135,  135,

   204

	SKIP,    1,

   205

	 137,  137,

   206

	SKIP,    1,

   207

	 139,  139,

   208

	 140,  140, // TODO Down arrow

   209

	 141,  141,

   210

	 142,  142, // TODO Check mark

   211

	 143,  143, // TODO Cross

   212

	 144,  144,

   213

	 145,  145, // TODO Right arrow

   214

	 146,  149,

   215

	 118,  122, // Transport markers

   216

	SKIP,    2,

   217

	 157,  157,

   218

	 114,  115, // Small up/down arrows

   219

	SKIP,    1,

   220

	 161,  225,

   221

/* Small font */

   222

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

   223

	SKIP,   36,

   224

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

   225

	 322,  322, // Up arrow

   226

	 355,  357,

   227

	SKIP,    1, // skip currency sign

   228

	 359,  359,

   229

	SKIP,    1,

   230

	 361,  361,

   231

	SKIP,    1,

   232

	 363,  363,

   233

	 364,  364, // TODO Down arrow

   234

	 365,  366,

   235

	SKIP,    1,

   236

	 368,  368,

   237

	 369,  369, // TODO Right arrow

   238

	 370,  373,

   239

	SKIP,    7,

   240

	 381,  381,

   241

	SKIP,    3,

   242

	 385,  449,

   243

/* Big font */

   244

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

   245

	SKIP,   36,

   246

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

   247

	SKIP,    1,

   248

	 579,  581,

   249

	SKIP,    1,

   250

	 583,  583,

   251

	SKIP,    5,

   252

	 589,  589,

   253

	SKIP,   15,

   254

	 605,  605,

   255

	SKIP,    3,

   256

	 609,  625,

   257

	SKIP,    1,

   258

	 627,  632,

   259

	SKIP,    1,

   260

	 634,  639,

   261

	SKIP,    1,

   262

	 641,  657,

   263

	SKIP,    1,

   264

	 659,  664,

   265

	SKIP,    2,

   266

	 667,  671,

   267

	SKIP,    1,

   268

	 673,  673,

   269

/* Graphics */

   270

	 674, 4792,

   271

	END

   272

};

   273

   274

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

   275

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

   276

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

   277

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

   278

 * a maximum use of sprite slots. */

   279

#define OPENTTD_SPRITES_COUNT 95

   280

static const SpriteID _openttd_grf_indexes[] = {

   281

	SPR_IMG_AUTORAIL, SPR_CURSOR_WAYPOINT, // icons etc

   282

	134, 134,  // euro symbol medium size

   283

	582, 582,  // euro symbol large size

   284

	358, 358,  // euro symbol tiny

   285

	SPR_CURSOR_CANAL, SPR_IMG_FASTFORWARD, // more icons

   286

	648, 648, // nordic char: æ

   287

	616, 616, // nordic char: Æ

   288

	666, 666, // nordic char: ø

   289

	634, 634, // nordic char: Ø

   290

	SPR_PIN_UP, SPR_CURSOR_CLONE, // more icons

   291

	382, 383, // ¼ ½ tiny

   292

	158, 159, // ¼ ½ medium

   293

	606, 607, // ¼ ½ large

   294

	360, 360, // ¦ tiny

   295

	362, 362, // ¨ tiny

   296

	136, 136, // ¦ medium

   297

	138, 138, // ¨ medium

   298

	584, 584, // ¦ large

   299

	586, 586, // ¨ large

   300

	626, 626, // Ð large

   301

	658, 658, // ð large

   302

	374, 374, // ´ tiny

   303

	378, 378, // ¸ tiny

   304

	150, 150, // ´ medium

   305

	154, 154, // ¸ medium

   306

	598, 598, // ´ large

   307

	602, 602, // ¸ large

   308

	640, 640, // Þ large

   309

	672, 672, // þ large

   310

	380, 380, // º tiny

   311

	156, 156, // º medium

   312

	604, 604, // º large

   313

	317, 320, // { | } ~ tiny

   314

	 93,  96, // { | } ~ medium

   315

	541, 544, // { | } ~ large

   316

	SPR_HOUSE_ICON, SPR_HOUSE_ICON,

   317

	585, 585, // § large

   318

	587, 587, // © large

   319

	592, 592, // ® large

   320

	594, 597, // ° ± ² ³ large

   321

	633, 633, // × large

   322

	665, 665, // ÷ large

   323

	END

   324

};

   325

   326

static byte _sprite_page_to_load = 0xFF;

   327

   328

static void LoadSpriteTables(void)

   329

{

   330

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

   331

	uint load_index;

   332

	uint i;

   333

   334

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

   335

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

   336

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

   337

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

   338

	load_index = 4793;

   339

   340

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

   341

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

   342

	}

   343

   344

	if (_sprite_page_to_load != 0) {

   345

		LoadGrfIndexed(

   346

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

   347

			_landscape_spriteindexes[_sprite_page_to_load - 1],

   348

			i++

   349

		);

   350

	}

   351

   352

	assert(load_index == SPR_CANALS_BASE);

   353

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

   354

   355

	assert(load_index == SPR_SLOPES_BASE);

   356

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

   357

   358

	load_index = SPR_AUTORAIL_BASE;

   359

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

   360

   364

	assert(load_index == SPR_2CCMAP_BASE);

   365

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

   366

   367

	assert(load_index == SPR_OPENTTD_BASE);

   368

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

   369

	load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT;

   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

}