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

#include <string.h>

    17

    18

typedef struct MD5File {

    19

	const char * const filename;     // filename

    20

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

    21

} MD5File;

    22

    23

typedef struct FileList {

    24

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

    25

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

    26

} FileList;

    27

    28

enum {

    29

	SKIP = 0xFFFE,

    30

	END  = 0xFFFF

    31

};

    32

    33

#include "table/files.h"

    34

#include "table/landscape_sprite.h"

    35

    36

static const SpriteID * const _landscape_spriteindexes[] = {

    37

	_landscape_spriteindexes_1,

    38

	_landscape_spriteindexes_2,

    39

	_landscape_spriteindexes_3,

    40

};

    41

    42

static const SpriteID * const _slopes_spriteindexes[] = {

    43

	_slopes_spriteindexes_0,

    44

	_slopes_spriteindexes_1,

    45

	_slopes_spriteindexes_2,

    46

	_slopes_spriteindexes_3,

    47

};

    48

    49

    50

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

    51

{

    52

	uint load_index_org = load_index;

    53

    54

	FioOpenFile(file_index, filename);

    55

    56

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

    57

    58

	while (LoadNextSprite(load_index, file_index)) {

    59

		load_index++;

    60

		if (load_index >= MAX_SPRITES) {

    61

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

    62

		}

    63

	}

    64

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

    65

    66

	return load_index - load_index_org;

    67

}

    68

    69

    70

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

    71

{

    72

	uint start;

    73

    74

	FioOpenFile(file_index, filename);

    75

    76

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

    77

    78

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

    79

		uint end = *index_tbl++;

    80

    81

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

    82

			SkipSprites(end);

    83

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

    84

			do {

    85

			#ifdef NDEBUG

    86

				LoadNextSprite(start, file_index);

    87

			#else

    88

				bool b = LoadNextSprite(start, file_index);

    89

				assert(b);

    90

			#endif

    91

			} while (++start <= end);

    92

		}

    93

	}

    94

}

    95

    96

    97

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

    98

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

    99

{

   100

	if (memcmp(file.hash, digest, sizeof(file.hash)) == 0) return true;

   101

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

   102

	return false;

   103

}

   104

   105

/* Calculate and check the MD5 hash of the supplied filename.

   106

 * returns true if the checksum is correct */

   107

static bool FileMD5(const MD5File file, bool warn)

   108

{

   109

	FILE *f;

   110

	char buf[MAX_PATH];

   111

   112

	// open file

   113

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

   114

	f = fopen(buf, "rb");

   115

   116

#if !defined(WIN32)

   117

	if (f == NULL) {

   118

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

   119

		f = fopen(buf, "rb");

   120

	}

   121

#endif

   122

   123

	if (f != NULL) {

   124

		md5_state_t filemd5state;

   125

		md5_byte_t buffer[1024];

   126

		md5_byte_t digest[16];

   127

		size_t len;

   128

   129

		md5_init(&filemd5state);

   130

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

   131

			md5_append(&filemd5state, buffer, len);

   132

   133

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

   134

		fclose(f);

   135

   136

		md5_finish(&filemd5state, digest);

   137

		return CheckMD5Digest(file, digest, warn);

   138

	} else { // file not found

   139

		return false;

   140

	}

   141

}

   142

   143

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

   144

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

   145

 * If neither are found, Windows palette is assumed.

   146

 *

   147

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

   148

void CheckExternalFiles(void)

   149

{

   150

	uint i;

   151

	// count of files from this version

   152

	uint dos = 0;

   153

	uint win = 0;

   154

   155

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

   156

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

   157

   158

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

   159

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

   160

   161

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

   162

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

   163

   164

	for (i = 0; i < lengthof(files_openttd); i++) {

   165

		if (!FileMD5(files_openttd[i], false)) {

   166

			fprintf(stderr, "Your %s file is corrupted or missing!\n", files_openttd[i].filename);

   167

		}

   168

	}

   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

	SKIP,   36,

   194

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

   195

	  98,   98, // Up arrow

   196

	 131,  133,

   197

	SKIP,    1, // skip currency sign

   198

	 135,  135,

   199

	SKIP,    1,

   200

	 137,  137,

   201

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

	SKIP,    2,

   212

	 157,  157,

   213

	 114,  115, // Small up/down arrows

   214

	SKIP,    1,

   215

	 161,  225,

   216

/* Small font */

   217

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

   218

	SKIP,   36,

   219

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

   220

	 322,  322, // Up arrow

   221

	 355,  357,

   222

	SKIP,    1, // skip currency sign

   223

	 359,  359,

   224

	SKIP,    1,

   225

	 361,  361,

   226

	SKIP,    1,

   227

	 363,  363,

   228

	 364,  364, // TODO Down arrow

   229

	 365,  366,

   230

	SKIP,    1,

   231

	 368,  368,

   232

	 369,  369, // TODO Right arrow

   233

	 370,  373,

   234

	SKIP,    7,

   235

	 381,  381,

   236

	SKIP,    3,

   237

	 385,  449,

   238

/* Big font */

   239

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

   240

	SKIP,   36,

   241

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

   242

	SKIP,    1,

   243

	 579,  581,

   244

	SKIP,    1,

   245

	 583,  583,

   246

	SKIP,    5,

   247

	 589,  589,

   248

	SKIP,   15,

   249

	 605,  605,

   250

	SKIP,    3,

   251

	 609,  625,

   252

	SKIP,    1,

   253

	 627,  632,

   254

	SKIP,    1,

   255

	 634,  639,

   256

	SKIP,    1,

   257

	 641,  657,

   258

	SKIP,    1,

   259

	 659,  664,

   260

	SKIP,    2,

   261

	 667,  671,

   262

	SKIP,    1,

   263

	 673,  673,

   264

/* Graphics */

   265

	 674, 4792,

   266

	END

   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

static const SpriteID _openttd_grf_indexes[] = {

   275

	SPR_IMG_AUTORAIL, SPR_CURSOR_WAYPOINT, // icons etc

   276

	134, 134,  // euro symbol medium size

   277

	582, 582,  // euro symbol large size

   278

	358, 358,  // euro symbol tiny

   279

	SPR_CURSOR_CANAL, SPR_IMG_FASTFORWARD, // more icons

   280

	648, 648, // nordic char: æ

   281

	616, 616, // nordic char: Æ

   282

	666, 666, // nordic char: ø

   283

	634, 634, // nordic char: Ø

   284

	SPR_PIN_UP, SPR_CURSOR_CLONE_TRAIN, // more icons

   285

	382, 383, // ¼ ½ tiny

   286

	158, 159, // ¼ ½ medium

   287

	606, 607, // ¼ ½ large

   288

	360, 360, // ¦ tiny

   289

	362, 362, // ¨ tiny

   290

	136, 136, // ¦ medium

   291

	138, 138, // ¨ medium

   292

	584, 584, // ¦ large

   293

	586, 586, // ¨ large

   294

	626, 626, // Ð large

   295

	658, 658, // ð large

   296

	374, 374, // ´ tiny

   297

	378, 378, // ¸ tiny

   298

	150, 150, // ´ medium

   299

	154, 154, // ¸ medium

   300

	598, 598, // ´ large

   301

	602, 602, // ¸ large

   302

	640, 640, // Þ large

   303

	672, 672, // þ large

   304

	380, 380, // º tiny

   305

	156, 156, // º medium

   306

	604, 604, // º large

   307

	317, 320, // { | } ~ tiny

   308

	 93,  96, // { | } ~ medium

   309

	541, 544, // { | } ~ large

   310

	SPR_HOUSE_ICON, SPR_HOUSE_ICON,

   311

	585, 585, // § large

   312

	587, 587, // © large

   313

	592, 592, // ® large

   314

	594, 597, // ° ± ² ³ large

   315

	633, 633, // × large

   316

	665, 665, // ÷ large

   317

	SPR_SELL_TRAIN, SPR_SHARED_ORDERS_ICON,

   321

	END

   322

};

   323

   324

static byte _sprite_page_to_load = 0xFF;

   325

   326

static void LoadSpriteTables(void)

   327

{

   328

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

   329

	uint load_index;

   330

	uint i;

   331

   332

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

   333

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

   334

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

   335

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

   336

	load_index = 4793;

   337

   338

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

   339

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

   340

	}

   341

   342

	if (_sprite_page_to_load != 0) {

   343

		LoadGrfIndexed(

   344

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

   345

			_landscape_spriteindexes[_sprite_page_to_load - 1],

   346

			i++

   347

		);

   348

	}

   349

   350

	assert(load_index == SPR_SIGNALS_BASE);

   351

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

   352

   353

	assert(load_index == SPR_CANALS_BASE);

   354

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

   355

   356

	assert(load_index == SPR_SLOPES_BASE);

   357

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

   358

   359

	load_index = SPR_AUTORAIL_BASE;

   360

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

   361

   362

	assert(load_index == SPR_ELRAIL_BASE);

   363

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

   364

   365

	assert(load_index == SPR_2CCMAP_BASE);

   366

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

   367

   368

	assert(load_index == SPR_OPENTTD_BASE);

   369

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

   370

	load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT;

   371

   372

	assert(load_index == SPR_AIRPORTX_BASE);

   373

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

   374

   375

	LoadNewGRF(load_index, i);

   376

}

   377

   378

   379

void GfxLoadSprites(void)

   380

{

   381

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

   382

	if (_sprite_page_to_load != _opt.landscape) {

   383

		_sprite_page_to_load = _opt.landscape;

   384

   385

		// Sprite cache

   386

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

   387

   388

		GfxInitSpriteMem();

   389

		LoadSpriteTables();

   390

		GfxInitPalettes();

   391

	}

   392

}