1

/* $Id$ */

     2

     3

/** @file gfxinit.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "functions.h"

     9

#include "gfx.h"

    10

#include "gfxinit.h"

    11

#include "spritecache.h"

    12

#include "table/sprites.h"

    13

#include "fileio.h"

    14

#include "fios.h"

    15

#include "string.h"

    16

#include "newgrf.h"

    17

#include "md5.h"

    18

#include "variables.h"

    19

#include "fontcache.h"

    20

#include <string.h>

    21

    22

struct MD5File {

    23

	const char * filename;     ///< filename

    24

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

    25

};

    26

    27

struct FileList {

    33

};

    34

    35

#include "table/files.h"

    36

#include "table/landscape_sprite.h"

    37

    38

static const SpriteID * const _landscape_spriteindexes[] = {

    39

	_landscape_spriteindexes_1,

    40

	_landscape_spriteindexes_2,

    41

	_landscape_spriteindexes_3,

    42

};

    43

    44

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

    45

{

    46

	uint load_index_org = load_index;

    47

	uint sprite_id = 0;

    48

    49

	FioOpenFile(file_index, filename);

    50

    51

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

    52

    53

	while (LoadNextSprite(load_index, file_index, sprite_id)) {

    54

		load_index++;

    55

		sprite_id++;

    56

		if (load_index >= MAX_SPRITES) {

    57

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

    58

		}

    59

	}

    60

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

    61

    62

	return load_index - load_index_org;

    63

}

    64

    65

    66

void LoadSpritesIndexed(int file_index, uint *sprite_id, const SpriteID *index_tbl)

    67

{

    68

	uint start;

    69

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

    70

		uint end = *index_tbl++;

    71

    72

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

    73

			SkipSprites(end);

    74

			(*sprite_id) += end;

    75

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

    76

			do {

    77

			#ifdef NDEBUG

    78

				LoadNextSprite(start, file_index, *sprite_id);

    79

			#else

    80

				bool b = LoadNextSprite(start, file_index, *sprite_id);

    81

				assert(b);

    82

			#endif

    83

				(*sprite_id)++;

    84

			} while (++start <= end);

    85

		}

    86

	}

    87

}

    88

    89

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

    90

{

    91

	uint sprite_id = 0;

    92

    93

	FioOpenFile(file_index, filename);

    94

    95

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

    96

    97

	LoadSpritesIndexed(file_index, &sprite_id, index_tbl);

    98

}

    99

   100

   101

/**

   102

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

   103

 * @param file filename and expected MD5 hash for the given filename.

   104

 * @return true if the checksum is correct.

   105

 */

   106

static bool FileMD5(const MD5File file)

   107

{

   108

	size_t size;

   109

	FILE *f = FioFOpenFile(file.filename, "rb", DATA_DIR, &size);

   110

   111

	if (f != NULL) {

   112

		md5_state_t filemd5state;

   113

		md5_byte_t buffer[1024];

   114

		md5_byte_t digest[16];

   115

		size_t len;

   116

   117

		md5_init(&filemd5state);

   118

		while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, f)) != 0 && size != 0) {

   119

			size -= len;

   120

			md5_append(&filemd5state, buffer, len);

   121

		}

   122

   123

		FioFCloseFile(f);

   124

   125

		md5_finish(&filemd5state, digest);

   126

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

   127

	} else { // file not found

   128

		return false;

   129

	}

   130

}

   131

   132

/**

   133

 * Determine the palette that has to be used.

   134

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

   135

 *  - all Windows files present -> Windows palette

   136

 *  - all DOS files present -> DOS palette

   137

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

   138

 *  - otherwise -> Windows palette

   139

 */

   140

static void DeterminePalette()

   141

{

   142

	if (_use_dos_palette) return;

   143

   144

	/* Count of files from the different versions. */

   145

	uint dos = 0;

   146

	uint win = 0;

   147

   148

	for (uint i = 0; i < lengthof(files_dos.basic); i++) if (FioCheckFileExists(files_dos.basic[i].filename)) dos++;

   149

	for (uint i = 0; i < lengthof(files_dos.landscape); i++) if (FioCheckFileExists(files_dos.landscape[i].filename)) dos++;

   150

   151

	for (uint i = 0; i < lengthof(files_win.basic); i++) if (FioCheckFileExists(files_win.basic[i].filename)) win++;

   152

	for (uint i = 0; i < lengthof(files_win.landscape); i++) if (FioCheckFileExists(files_win.landscape[i].filename)) win++;

   153

   154

	if (win == 5) {

   155

		_use_dos_palette = false;

   156

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

   157

		_use_dos_palette = true;

   158

	} else {

   159

		_use_dos_palette = false;

   160

	}

   161

}

   162

   163

/**

   164

 * Checks whether the MD5 checksums of the files are correct.

   165

 *

   166

 * @note Also checks sample.cat and other required non-NewGRF GRFs for corruption.

   167

 */

   168

void CheckExternalFiles()

   169

{

   170

	DeterminePalette();

   171

   172

	static const size_t ERROR_MESSAGE_LENGTH = 128;

   173

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

   175

	error_msg[0] = '\0';

   176

	char *add_pos = error_msg;

   177

   178

	for (uint i = 0; i < lengthof(files->basic); i++) {

   179

		if (!FileMD5(files->basic[i])) {

   180

			add_pos += snprintf(add_pos, ERROR_MESSAGE_LENGTH, "Your '%s' file is corrupted or missing! You can find '%s' on your Transport Tycoon Deluxe CD-ROM.\n", files->basic[i].filename, files->basic[i].filename);

   181

		}

   182

	}

   183

   184

	for (uint i = 0; i < lengthof(files->landscape); i++) {

   185

		if (!FileMD5(files->landscape[i])) {

   186

			add_pos += snprintf(add_pos, ERROR_MESSAGE_LENGTH, "Your '%s' file is corrupted or missing! You can find '%s' on your Transport Tycoon Deluxe CD-ROM.\n", files->landscape[i].filename, files->landscape[i].filename);

   187

		}

   188

	}

   189

   191

		add_pos += snprintf(add_pos, ERROR_MESSAGE_LENGTH, "Your 'sample.cat' file is corrupted or missing! You can find 'sample.cat' on your Transport Tycoon Deluxe CD-ROM.\n");

   192

	}

   193

   200

	}

   201

   202

	if (add_pos != error_msg) ShowInfoF(error_msg);

   203

}

   204

   205

   206

static const SpriteID trg1idx[] = {

   207

	   0,    1, ///< Mouse cursor, ZZZ

   208

/* Medium font */

   209

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

   210

	SKIP,   36,

   211

	 160,  160, ///< Move Ÿ to the correct position

   212

	  98,   98, ///< Up arrow

   213

	 131,  133,

   214

	SKIP,    1, ///< skip currency sign

   215

	 135,  135,

   216

	SKIP,    1,

   217

	 137,  137,

   218

	SKIP,    1,

   219

	 139,  139,

   220

	 140,  140, ///< @todo Down arrow

   221

	 141,  141,

   222

	 142,  142, ///< @todo Check mark

   223

	 143,  143, ///< @todo Cross

   224

	 144,  144,

   225

	 145,  145, ///< @todo Right arrow

   226

	 146,  149,

   227

	 118,  122, ///< Transport markers

   228

	SKIP,    2,

   229

	 157,  157,

   230

	 114,  115, ///< Small up/down arrows

   231

	SKIP,    1,

   232

	 161,  225,

   233

/* Small font */

   234

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

   235

	SKIP,   36,

   236

	 384,  384, ///< Move Ÿ to the correct position

   237

	 322,  322, ///< Up arrow

   238

	 355,  357,

   239

	SKIP,    1, ///< skip currency sign

   240

	 359,  359,

   241

	SKIP,    1,

   242

	 361,  361,

   243

	SKIP,    1,

   244

	 363,  363,

   245

	 364,  364, ////< @todo Down arrow

   246

	 365,  366,

   247

	SKIP,    1,

   248

	 368,  368,

   249

	 369,  369, ///< @todo Right arrow

   250

	 370,  373,

   251

	SKIP,    7,

   252

	 381,  381,

   253

	SKIP,    3,

   254

	 385,  449,

   255

/* Big font */

   256

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

   257

	SKIP,   36,

   258

	 608,  608, ///< Move Ÿ to the correct position

   259

	SKIP,    1,

   260

	 579,  581,

   261

	SKIP,    1,

   262

	 583,  583,

   263

	SKIP,    5,

   264

	 589,  589,

   265

	SKIP,   15,

   266

	 605,  605,

   267

	SKIP,    3,

   268

	 609,  625,

   269

	SKIP,    1,

   270

	 627,  632,

   271

	SKIP,    1,

   272

	 634,  639,

   273

	SKIP,    1,

   274

	 641,  657,

   275

	SKIP,    1,

   276

	 659,  664,

   277

	SKIP,    2,

   278

	 667,  671,

   279

	SKIP,    1,

   280

	 673,  673,

   281

/* Graphics */

   282

	 674, 4792,

   283

	END

   284

};

   285

   291

	648, 648, ///<  nordic char: æ

   292

	616, 616, ///<  nordic char: Æ

   293

	666, 666, ///<  nordic char: ø

   294

	634, 634, ///<  nordic char: Ø

   295

	382, 383, ///<  Œ œ tiny

   296

	158, 159, ///<  Œ œ medium

   297

	606, 607, ///<  Œ œ large

   298

	360, 360, ///<  Š tiny

   299

	362, 362, ///<  š tiny

   300

	136, 136, ///<  Š medium

   301

	138, 138, ///<  š medium

   302

	584, 584, ///<  Š large

   303

	586, 586, ///<  š large

   304

	626, 626, ///<  Ð large

   305

	658, 658, ///<  ð large

   306

	374, 374, ///<  Ž tiny

   307

	378, 378, ///<  ž tiny

   308

	150, 150, ///<  Ž medium

   309

	154, 154, ///<  ž medium

   310

	598, 598, ///<  Ž large

   311

	602, 602, ///<  ž large

   312

	640, 640, ///<  Þ large

   313

	672, 672, ///<  þ large

   314

	380, 380, ///<  º tiny

   315

	156, 156, ///<  º medium

   316

	604, 604, ///<  º large

   317

	317, 320, ///<  { | } ~ tiny

   318

	 93,  96, ///<  { | } ~ medium

   319

	541, 544, ///<  { | } ~ large

   320

	585, 585, ///<  § large

   321

	587, 587, ///<  © large

   322

	592, 592, ///<  ® large

   323

	594, 597, ///<  ° ± ² ³ large

   324

	633, 633, ///<  × large

   325

	665, 665, ///<  ÷ large

   326

	377, 377, ///<  · small

   327

	153, 153, ///<  · medium

   328

	601, 601, ///<  · large

   329

	END

   330

};

   331

   332

   333

static void LoadSpriteTables()

   334

{

   335

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

   336

	uint i = FIRST_GRF_SLOT;

   337

   338

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

   339

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

   340

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

   341

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

   342

   343

	/*

   344

	 * The second basic file always starts at the given location and does

   345

	 * contain a different amount of sprites depending on the "type"; DOS

   346

	 * has a few sprites less. However, we do not care about those missing

   347

	 * sprites as they are not shown anyway (logos in intro game).

   348

	 */

   349

	LoadGrfFile(files->basic[1].filename, 4793, i++);

   350

   351

	/*

   352

	 * Load additional sprites for climates other than temperate.

   353

	 * This overwrites some of the temperate sprites, such as foundations

   354

	 * and the ground sprites.

   355

	 */

   356

	if (_opt.landscape != LT_TEMPERATE) {

   357

		LoadGrfIndexed(

   358

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

   359

			_landscape_spriteindexes[_opt.landscape - 1],

   360

			i++

   361

		);

   362

	}

   363

   365

   366

	/* Initialize the unicode to sprite mapping table */

   367

	InitializeUnicodeGlyphMap();

   368

   387

}

   388

   389

   390

void GfxLoadSprites()

   391

{

   392

	DEBUG(sprite, 2, "Loading sprite set %d", _opt.landscape);

   393

   394

	GfxInitSpriteMem();

   395

	LoadSpriteTables();

   396

	GfxInitPalettes();

   397

}