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

   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,   25,

   219

	   342,  346, // place holders for transport markers

   220

	0xFFFE,    6,

   221

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

   223

	   355,  357,

   224

	0xFFFE,    1, // skip currency sign

   225

	   359,  359,

   226

	0xFFFE,    1,

   227

	   361,  361,

   228

	0xFFFE,    1,

   229

	   363,  363,

   230

	   364,  364, // TODO Down arrow

   231

	   365,  366,

   232

	0xFFFE,    1,

   233

	   368,  368,

   234

	   369,  369, // TODO Right arrow

   235

	   370,  373,

   236

	0xFFFE,    7,

   237

	   381,  381,

   238

	0xFFFE,    3,

   239

	   385,  449,

   240

/* Big font */

   241

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

   242

	0xFFFE,   36,

   243

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

   244

	0xFFFE,    1,

   245

	   579,  581,

   246

	0xFFFE,    1,

   247

	   583,  583,

   248

	0xFFFE,    5,

   249

	   589,  589,

   250

	0xFFFE,   15,

   251

	   605,  605,

   252

	0xFFFE,    3,

   253

	   609,  625,

   254

	0xFFFE,    1,

   255

	   627,  632,

   256

	0xFFFE,    1,

   257

	   634,  639,

   258

	0xFFFE,    1,

   259

	   641,  657,

   260

	0xFFFE,    1,

   261

	   659,  664,

   262

	0xFFFE,    2,

   263

	   667,  671,

   264

	0xFFFE,    1,

   265

	   673,  673,

   266

/* Graphics */

   267

	   674, 4792,

   268

	0xFFFF

   269

};

   270

   271

#define OPENTTD_SPRITES_COUNT 100

   272

static const SpriteID _openttd_grf_indexes[] = {

   273

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

   274

	134, 134,  // euro symbol medium size

   275

	582, 582,  // euro symbol large size

   276

	358, 358,  // euro symbol tiny

   277

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

   278

	648, 648, // nordic char: æ

   279

	616, 616, // nordic char: Æ

   280

	666, 666, // nordic char: ø

   281

	634, 634, // nordic char: Ø

   282

	SPR_OPENTTD_BASE+62, SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT, // more icons

   283

	382, 383, // ¼ ½ tiny

   284

	158, 159, // ¼ ½ medium

   285

	606, 607, // ¼ ½ large

   286

	360, 360, // ¦ tiny

   287

	362, 362, // ¨ tiny

   288

	136, 136, // ¦ medium

   289

	138, 138, // ¨ medium

   290

	584, 584, // ¦ large

   291

	586, 586, // ¨ large

   292

	626, 626, // Ð large

   293

	658, 658, // ð large

   294

	374, 374, // ´ tiny

   295

	378, 378, // ¸ tiny

   296

	150, 150, // ´ medium

   297

	154, 154, // ¸ medium

   298

	598, 598, // ´ large

   299

	602, 602, // ¸ large

   300

	640, 640, // Þ large

   301

	672, 672, // þ large

   302

	380, 380, // º tiny

   303

	156, 156, // º medium

   304

	604, 604, // º large

   305

	0xffff,

   306

};

   307

   308

static byte _sprite_page_to_load = 0xFF;

   309

   310

static void LoadSpriteTables(void)

   311

{

   312

	uint load_index = 0;

   313

	uint i;

   314

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

   315

   316

	files = _use_dos_palette? &files_dos : &files_win;

   317

   318

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

   322

	load_index = 4793;

   323

   324

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

   325

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

   326

	}

   327

   328

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

   329

   330

	if (_sprite_page_to_load != 0) {

   331

		LoadGrfIndexed(

   332

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

   333

			_landscape_spriteindexes[_sprite_page_to_load - 1],

   334

			i++

   335

		);

   336

	}

   337

   338

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

   339

   340

	load_index = SPR_AUTORAIL_BASE;

   341

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

   342

   343

	load_index = SPR_CANALS_BASE;

   344

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

   345

   346

	load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT + 1;

   347

   348

	LoadNewGRF(load_index, i);

   349

}

   350

   351

   352

void GfxLoadSprites(void)

   353

{

   354

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

   355

	if (_sprite_page_to_load != _opt.landscape) {

   356

		_sprite_page_to_load = _opt.landscape;

   357

   358

		// Sprite cache

   359

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

   360

   361

		GfxInitSpriteMem();

   362

		LoadSpriteTables();

   363

		GfxInitPalettes();

   364

	}

   365

}