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

#define OPENTTD_SPRITES_COUNT 100

   270

static const SpriteID _openttd_grf_indexes[] = {

   271

	SPR_OPENTTD_BASE + 0, SPR_OPENTTD_BASE + 7, // icons etc

   272

	134, 134,  // euro symbol medium size

   273

	582, 582,  // euro symbol large size

   274

	358, 358,  // euro symbol tiny

   275

	SPR_OPENTTD_BASE+11, SPR_OPENTTD_BASE+57, // more icons

   276

	648, 648, // nordic char: æ

   277

	616, 616, // nordic char: Æ

   278

	666, 666, // nordic char: ø

   279

	634, 634, // nordic char: Ø

   280

	SPR_OPENTTD_BASE+62, SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT, // 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

	0xffff,

   307

};

   308

   309

static byte _sprite_page_to_load = 0xFF;

   310

   311

static void LoadSpriteTables(void)

   312

{

   313

	uint load_index = 0;

   314

	uint i;

   315

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

   316

   317

	files = _use_dos_palette? &files_dos : &files_win;

   318

   319

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

   320

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

   321

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

   322

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

   323

	load_index = 4793;

   324

   325

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

   326

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

   327

	}

   328

   329

	if (_sprite_page_to_load != 0) {

   330

		LoadGrfIndexed(

   331

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

   332

			_landscape_spriteindexes[_sprite_page_to_load - 1],

   333

			i++

   334

		);

   335

	}

   336

   341

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

   342

   343

	load_index = SPR_AUTORAIL_BASE;

   344

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

   345

   348

   351

	load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT + 1;

   352

   353

	LoadNewGRF(load_index, i);

   354

}

   355

   356

   357

void GfxLoadSprites(void)

   358

{

   359

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

   360

	if (_sprite_page_to_load != _opt.landscape) {

   361

		_sprite_page_to_load = _opt.landscape;

   362

   363

		// Sprite cache

   364

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

   365

   366

		GfxInitSpriteMem();

   367

		LoadSpriteTables();

   368

		GfxInitPalettes();

   369

	}

   370

}