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

#include "table/files.h"

    28

#include "table/landscape_sprite.h"

    29

    30

static const SpriteID * const _landscape_spriteindexes[] = {

    31

	_landscape_spriteindexes_1,

    32

	_landscape_spriteindexes_2,

    33

	_landscape_spriteindexes_3,

    34

};

    35

    36

static const SpriteID * const _slopes_spriteindexes[] = {

    37

	_slopes_spriteindexes_0,

    38

	_slopes_spriteindexes_1,

    39

	_slopes_spriteindexes_2,

    40

	_slopes_spriteindexes_3,

    41

};

    42

    43

    44

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

    45

{

    46

	uint load_index_org = load_index;

    47

    48

	FioOpenFile(file_index, filename);

    49

    50

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

    51

    52

	while (LoadNextSprite(load_index, file_index)) {

    53

		load_index++;

    54

		if (load_index >= MAX_SPRITES) {

    55

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

    56

		}

    57

	}

    58

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

    59

    60

	return load_index - load_index_org;

    61

}

    62

    63

    64

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

    65

{

    66

	uint start;

    67

    68

	FioOpenFile(file_index, filename);

    69

    70

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

    71

    72

	for (; (start = *index_tbl++) != 0xffff;) {

    73

		uint end = *index_tbl++;

    74

    75

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

    76

			SkipSprites(end);

    77

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

    78

			do {

    79

			#ifdef NDEBUG

    80

				LoadNextSprite(start, file_index);

    81

			#else

    82

				bool b = LoadNextSprite(start, file_index);

    83

				assert(b);

    84

			#endif

    85

			} while (++start <= end);

    86

		}

    87

	}

    88

}

    89

    90

    91

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

    92

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

    93

{

    94

	uint i;

    95

    96

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

    97

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

    98

    99

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

   100

	if (i == 16) {

   101

		return true;

   102

	} else {

   103

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

   104

		return false;

   105

	};

   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

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

   117

	f = fopen(buf, "rb");

   118

   119

#if !defined(WIN32)

   120

	if (f == NULL) {

   121

		char *s;

   122

	// make lower case and check again

   123

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

   124

			*s = tolower(*s);

   125

		f = fopen(buf, "rb");

   126

	}

   127

#endif

   128

   129

	if (f != NULL) {

   130

		md5_state_t filemd5state;

   131

		md5_byte_t buffer[1024];

   132

		md5_byte_t digest[16];

   133

		size_t len;

   134

   135

		md5_init(&filemd5state);

   136

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

   137

			md5_append(&filemd5state, buffer, len);

   138

   139

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

   140

		fclose(f);

   141

   142

		md5_finish(&filemd5state, digest);

   143

	  return CheckMD5Digest(file, digest, warn);

   144

	} else { // file not found

   145

		return false;

   146

	}

   147

}

   148

   149

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

   150

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

   151

 * If neither are found, Windows palette is assumed.

   152

 *

   153

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

   154

void CheckExternalFiles(void)

   155

{

   156

	uint i;

   157

	// count of files from this version

   158

	uint dos = 0;

   159

	uint win = 0;

   160

   161

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

   162

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

   163

   164

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

   165

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

   166

   167

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

   168

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

   169

   170

	/*

   171

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

   172

	 * all Windows files present -> Windows palette

   173

	 * all DOS files present -> DOS palette

   174

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

   175

	 * otherwise -> Windows palette

   176

	 */

   177

	if (_use_dos_palette) {

   178

		return;

   179

	} else if (win == 5) {

   180

		_use_dos_palette = false;

   181

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

   182

		_use_dos_palette = true;

   183

	} else {

   184

		_use_dos_palette = false;

   185

	}

   186

}

   187

   188

   189

static const SpriteID trg1idx[] = {

   190

	     0,    1, // Mouse cursor, ZZZ

   191

/* Medium font */

   192

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

   193

	0xFFFE,   36,

   194

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

   195

	    98,   98, // Up arrow

   196

	   131,  133,

   197

	0xFFFE,    1, // skip currency sign

   198

	   135,  135,

   199

	0xFFFE,    1,

   200

	   137,  137,

   201

	0xFFFE,    1,

   202

	   139,  139,

   203

	   140,  140, // TODO Down arrow

   204

	   141,  141,

   205

	   142,  142, // TODO Check mark

   206

	   143,  143, // TODO Cross

   207

	   144,  144,

   208

	   145,  145, // TODO Right arrow

   209

	   146,  149,

   210

	   118,  122, // Transport markers

   211

	0xFFFE,    2,

   212

	   157,  157,

   213

	   114,  115, // Small up/down arrows

   214

	0xFFFE,    1,

   215

	   161,  225,

   216

/* Small font */

   217

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

   218

	0xFFFE,   36,

   219

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

   220

	   322,  322, // Up arrow

   221

	   355,  357,

   222

	0xFFFE,    1, // skip currency sign

   223

	   359,  359,

   224

	0xFFFE,    1,

   225

	   361,  361,

   226

	0xFFFE,    1,

   227

	   363,  363,

   228

	   364,  364, // TODO Down arrow

   229

	   365,  366,

   230

	0xFFFE,    1,

   231

	   368,  368,

   232

	   369,  369, // TODO Right arrow

   233

	   370,  373,

   234

	0xFFFE,    7,

   235

	   381,  381,

   236

	0xFFFE,    3,

   237

	   385,  449,

   238

/* Big font */

   239

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

   240

	0xFFFE,   36,

   241

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

   242

	0xFFFE,    1,

   243

	   579,  581,

   244

	0xFFFE,    1,

   245

	   583,  583,

   246

	0xFFFE,    5,

   247

	   589,  589,

   248

	0xFFFE,   15,

   249

	   605,  605,

   250

	0xFFFE,    3,

   251

	   609,  625,

   252

	0xFFFE,    1,

   253

	   627,  632,

   254

	0xFFFE,    1,

   255

	   634,  639,

   256

	0xFFFE,    1,

   257

	   641,  657,

   258

	0xFFFE,    1,

   259

	   659,  664,

   260

	0xFFFE,    2,

   261

	   667,  671,

   262

	0xFFFE,    1,

   263

	   673,  673,

   264

/* Graphics */

   265

	   674, 4792,

   266

	0xFFFF

   267

};

   268

   269

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

   270

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

   271

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

   272

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

   273

 * a maximum use of sprite slots. */

   274

#define OPENTTD_SPRITES_COUNT 101

   275

static const SpriteID _openttd_grf_indexes[] = {

   276

	SPR_IMG_AUTORAIL, SPR_CURSOR_WAYPOINT, // icons etc

   277

	134, 134,  // euro symbol medium size

   278

	582, 582,  // euro symbol large size

   279

	358, 358,  // euro symbol tiny

   280

	SPR_CURSOR_CANAL, SPR_IMG_FASTFORWARD, // more icons

   281

	648, 648, // nordic char: æ

   282

	616, 616, // nordic char: Æ

   283

	666, 666, // nordic char: ø

   284

	634, 634, // nordic char: Ø

   285

	SPR_PIN_UP, SPR_CURSOR_CLONE, // more icons

   286

	382, 383, // ¼ ½ tiny

   287

	158, 159, // ¼ ½ medium

   288

	606, 607, // ¼ ½ large

   289

	360, 360, // ¦ tiny

   290

	362, 362, // ¨ tiny

   291

	136, 136, // ¦ medium

   292

	138, 138, // ¨ medium

   293

	584, 584, // ¦ large

   294

	586, 586, // ¨ large

   295

	626, 626, // Ð large

   296

	658, 658, // ð large

   297

	374, 374, // ´ tiny

   298

	378, 378, // ¸ tiny

   299

	150, 150, // ´ medium

   300

	154, 154, // ¸ medium

   301

	598, 598, // ´ large

   302

	602, 602, // ¸ large

   303

	640, 640, // Þ large

   304

	672, 672, // þ large

   305

	380, 380, // º tiny

   306

	156, 156, // º medium

   307

	604, 604, // º large

   308

	317, 320, // { | } ~ tiny

   309

	 93,  96, // { | } ~ medium

   310

	541, 544, // { | } ~ large

   311

	SPR_HOUSE_ICON, SPR_HOUSE_ICON,

   312

	0xffff,

   313

};

   314

   315

static byte _sprite_page_to_load = 0xFF;

   316

   317

static void LoadSpriteTables(void)

   318

{

   319

	uint load_index = 0;

   320

	uint i;

   321

	const FileList *files; // list of grf files to be loaded. Either Windows files or DOS files

   322

   323

	files = _use_dos_palette? &files_dos : &files_win;

   324

   325

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

   326

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

   327

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

   328

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

   329

	load_index = 4793;

   330

   331

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

   332

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

   333

	}

   334

   335

	if (_sprite_page_to_load != 0) {

   336

		LoadGrfIndexed(

   337

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

   338

			_landscape_spriteindexes[_sprite_page_to_load - 1],

   339

			i++

   340

		);

   341

	}

   342

   343

	assert(load_index == SPR_CANALS_BASE);

   344

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

   345

   346

	assert(load_index == SPR_SLOPES_BASE);

   347

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

   348

   349

	load_index = SPR_AUTORAIL_BASE;

   350

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

   351

   352

	assert(load_index == SPR_OPENTTD_BASE);

   353

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

   354

	load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT + 1;

   355

   356

	LoadNewGRF(load_index, i);

   357

}

   358

   359

   360

void GfxLoadSprites(void)

   361

{

   362

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

   363

	if (_sprite_page_to_load != _opt.landscape) {

   364

		_sprite_page_to_load = _opt.landscape;

   365

   366

		// Sprite cache

   367

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

   368

   369

		GfxInitSpriteMem();

   370

		LoadSpriteTables();

   371

		GfxInitPalettes();

   372

	}

   373

}