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[5];     // 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

	/*

   165

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

   166

	 * all Windows files present -> Windows palette

   167

	 * all DOS files present -> DOS palette

   168

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

   169

	 * otherwise -> Windows palette

   170

	 */

   171

	if (_use_dos_palette) {

   172

		return;

   173

	} else if (win == 5) {

   174

		_use_dos_palette = false;

   175

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

   176

		_use_dos_palette = true;

   177

	} else {

   178

		_use_dos_palette = false;

   179

	}

   180

}

   181

   182

   183

static const SpriteID trg1idx[] = {

   184

	   0,    1, // Mouse cursor, ZZZ

   185

/* Medium font */

   186

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

   187

	SKIP,   36,

   188

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

   189

	  98,   98, // Up arrow

   190

	 131,  133,

   191

	SKIP,    1, // skip currency sign

   192

	 135,  135,

   193

	SKIP,    1,

   194

	 137,  137,

   195

	SKIP,    1,

   196

	 139,  139,

   197

	 140,  140, // TODO Down arrow

   198

	 141,  141,

   199

	 142,  142, // TODO Check mark

   200

	 143,  143, // TODO Cross

   201

	 144,  144,

   202

	 145,  145, // TODO Right arrow

   203

	 146,  149,

   204

	 118,  122, // Transport markers

   205

	SKIP,    2,

   206

	 157,  157,

   207

	 114,  115, // Small up/down arrows

   208

	SKIP,    1,

   209

	 161,  225,

   210

/* Small font */

   211

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

   212

	SKIP,   36,

   213

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

   214

	 322,  322, // Up arrow

   215

	 355,  357,

   216

	SKIP,    1, // skip currency sign

   217

	 359,  359,

   218

	SKIP,    1,

   219

	 361,  361,

   220

	SKIP,    1,

   221

	 363,  363,

   222

	 364,  364, // TODO Down arrow

   223

	 365,  366,

   224

	SKIP,    1,

   225

	 368,  368,

   226

	 369,  369, // TODO Right arrow

   227

	 370,  373,

   228

	SKIP,    7,

   229

	 381,  381,

   230

	SKIP,    3,

   231

	 385,  449,

   232

/* Big font */

   233

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

   234

	SKIP,   36,

   235

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

   236

	SKIP,    1,

   237

	 579,  581,

   238

	SKIP,    1,

   239

	 583,  583,

   240

	SKIP,    5,

   241

	 589,  589,

   242

	SKIP,   15,

   243

	 605,  605,

   244

	SKIP,    3,

   245

	 609,  625,

   246

	SKIP,    1,

   247

	 627,  632,

   248

	SKIP,    1,

   249

	 634,  639,

   250

	SKIP,    1,

   251

	 641,  657,

   252

	SKIP,    1,

   253

	 659,  664,

   254

	SKIP,    2,

   255

	 667,  671,

   256

	SKIP,    1,

   257

	 673,  673,

   258

/* Graphics */

   259

	 674, 4792,

   260

	END

   261

};

   262

   263

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

   264

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

   265

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

   266

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

   267

 * a maximum use of sprite slots. */

   268

#define OPENTTD_SPRITES_COUNT 109

   269

static const SpriteID _openttd_grf_indexes[] = {

   270

	SPR_IMG_AUTORAIL, SPR_CURSOR_WAYPOINT, // icons etc

   271

	134, 134,  // euro symbol medium size

   272

	582, 582,  // euro symbol large size

   273

	358, 358,  // euro symbol tiny

   274

	SPR_CURSOR_CANAL, SPR_IMG_FASTFORWARD, // more icons

   275

	648, 648, // nordic char: æ

   276

	616, 616, // nordic char: Æ

   277

	666, 666, // nordic char: ø

   278

	634, 634, // nordic char: Ø

   279

	SPR_PIN_UP, SPR_CURSOR_CLONE, // more icons

   280

	382, 383, // ¼ ½ tiny

   281

	158, 159, // ¼ ½ medium

   282

	606, 607, // ¼ ½ large

   283

	360, 360, // ¦ tiny

   284

	362, 362, // ¨ tiny

   285

	136, 136, // ¦ medium

   286

	138, 138, // ¨ medium

   287

	584, 584, // ¦ large

   288

	586, 586, // ¨ large

   289

	626, 626, // Ð large

   290

	658, 658, // ð large

   291

	374, 374, // ´ tiny

   292

	378, 378, // ¸ tiny

   293

	150, 150, // ´ medium

   294

	154, 154, // ¸ medium

   295

	598, 598, // ´ large

   296

	602, 602, // ¸ large

   297

	640, 640, // Þ large

   298

	672, 672, // þ large

   299

	380, 380, // º tiny

   300

	156, 156, // º medium

   301

	604, 604, // º large

   302

	317, 320, // { | } ~ tiny

   303

	 93,  96, // { | } ~ medium

   304

	541, 544, // { | } ~ large

   305

	SPR_HOUSE_ICON, SPR_HOUSE_ICON,

   306

	585, 585, // § large

   307

	587, 587, // © large

   308

	592, 592, // ® large

   309

	594, 597, // ° ± ² ³ large

   310

	633, 633, // × large

   311

	665, 665, // ÷ large

   312

	SPR_SELL_TRAIN, SPR_SELL_CHAIN_TRAIN,

   313

	END

   314

};

   315

   316

static byte _sprite_page_to_load = 0xFF;

   317

   318

static void LoadSpriteTables(void)

   319

{

   320

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

   321

	uint load_index;

   322

	uint i;

   323

   324

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

   325

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

   326

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

   327

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

   328

	load_index = 4793;

   329

   330

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

   331

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

   332

	}

   333

   334

	if (_sprite_page_to_load != 0) {

   335

		LoadGrfIndexed(

   336

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

   337

			_landscape_spriteindexes[_sprite_page_to_load - 1],

   338

			i++

   339

		);

   340

	}

   341

   342

	assert(load_index == SPR_CANALS_BASE);

   343

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

   344

   345

	assert(load_index == SPR_SLOPES_BASE);

   346

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

   347

   348

	load_index = SPR_AUTORAIL_BASE;

   349

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

   350

   351

	assert(load_index == SPR_ELRAIL_BASE);

   352

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

   353

   354

	assert(load_index == SPR_2CCMAP_BASE);

   355

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

   356

   357

	assert(load_index == SPR_OPENTTD_BASE);

   358

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

   359

	load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT;

   360

   361

	assert(load_index == SPR_AIRPORTX_BASE);

   362

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

   363

   364

	LoadNewGRF(load_index, i);

   365

}

   366

   367

   368

void GfxLoadSprites(void)

   369

{

   370

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

   371

	if (_sprite_page_to_load != _opt.landscape) {

   372

		_sprite_page_to_load = _opt.landscape;

   373

   374

		// Sprite cache

   375

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

   376

   377

		GfxInitSpriteMem();

   378

		LoadSpriteTables();

   379

		GfxInitPalettes();

   380

	}

   381

}