1

/* $Id$ */

     2

     3

/** @file gfxinit.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "gfxinit.h"

     9

#include "spritecache.h"

    10

#include "table/sprites.h"

    11

#include "fileio.h"

    12

#include "fios.h"

    13

#include "newgrf.h"

    14

#include "md5.h"

    15

#include "variables.h"

    16

#include "fontcache.h"

    19

#include <string.h>

    20

    21

struct MD5File {

    22

	const char * filename;     ///< filename

    24

};

    25

    26

struct FileList {

    27

	MD5File basic[2];     ///< GRF files that always have to be loaded

    28

	MD5File landscape[3]; ///< Landscape specific grf files

    29

	MD5File sound;        ///< Sound samples

    30

	MD5File chars;        ///< GRF File with character replacements

    31

	MD5File openttd;      ///< GRF File with OTTD specific graphics

    32

};

    33

    34

#include "table/files.h"

    35

#include "table/landscape_sprite.h"

    36

    37

static const SpriteID * const _landscape_spriteindexes[] = {

    38

	_landscape_spriteindexes_1,

    39

	_landscape_spriteindexes_2,

    40

	_landscape_spriteindexes_3,

    41

};

    42

    43

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

    44

{

    45

	uint load_index_org = load_index;

    46

	uint sprite_id = 0;

    47

    48

	FioOpenFile(file_index, filename);

    49

    50

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

    51

    52

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

    53

		load_index++;

    54

		sprite_id++;

    55

		if (load_index >= MAX_SPRITES) {

    56

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

    57

		}

    58

	}

    59

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

    60

    61

	return load_index - load_index_org;

    62

}

    63

    64

    65

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

    66

{

    67

	uint start;

    68

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

    69

		uint end = *index_tbl++;

    70

    71

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

    72

			SkipSprites(end);

    73

			(*sprite_id) += end;

    74

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

    75

			do {

    76

			#ifdef NDEBUG

    77

				LoadNextSprite(start, file_index, *sprite_id);

    78

			#else

    79

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

    80

				assert(b);

    81

			#endif

    82

				(*sprite_id)++;

    83

			} while (++start <= end);

    84

		}

    85

	}

    86

}

    87

    88

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

    89

{

    90

	uint sprite_id = 0;

    91

    92

	FioOpenFile(file_index, filename);

    93

    94

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

    95

    96

	LoadSpritesIndexed(file_index, &sprite_id, index_tbl);

    97

}

    98

    99

   100

/**

   101

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

   102

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

   103

 * @return true if the checksum is correct.

   104

 */

   105

static bool FileMD5(const MD5File file)

   106

{

   107

	size_t size;

   108

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

   109

   110

	if (f != NULL) {

   114

		size_t len;

   115

   116

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

   117

			size -= len;

   119

		}

   120

   121

		FioFCloseFile(f);

   122

   124

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

   125

	} else { // file not found

   126

		return false;

   127

	}

   128

}

   129

   130

/**

   131

 * Determine the palette that has to be used.

   132

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

   133

 *  - all Windows files present -> Windows palette

   134

 *  - all DOS files present -> DOS palette

   135

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

   136

 *  - otherwise -> Windows palette

   137

 */

   138

static void DeterminePalette()

   139

{

   140

	if (_use_dos_palette) return;

   141

   142

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

   143

	uint dos = 0;

   144

	uint win = 0;

   145

   146

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

   147

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

   148

   149

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

   150

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

   151

   152

	if (win == 5) {

   153

		_use_dos_palette = false;

   154

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

   155

		_use_dos_palette = true;

   156

	} else {

   157

		_use_dos_palette = false;

   158

	}

   159

}

   160

   161

/**

   162

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

   163

 *

   164

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

   165

 */

   166

void CheckExternalFiles()

   167

{

   168

	DeterminePalette();

   169

   170

	static const size_t ERROR_MESSAGE_LENGTH = 128;

   171

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

   172

	char error_msg[ERROR_MESSAGE_LENGTH * (lengthof(files->basic) + lengthof(files->landscape) + 3)];

   173

	error_msg[0] = '\0';

   174

	char *add_pos = error_msg;

   175

   176

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

   177

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

   178

			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);

   179

		}

   180

	}

   181

   182

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

   183

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

   184

			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);

   185

		}

   186

	}

   187

   188

	if (!FileMD5(files_win.sound) && !FileMD5(files_dos.sound)) {

   189

		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");

   190

	}

   191

   192

	if (!FileMD5(files->chars)) {

   193

		add_pos += snprintf(add_pos, ERROR_MESSAGE_LENGTH, "Your '%s' file is corrupted or missing! The file was part of your installation.\n", files->chars.filename);

   194

	}

   195

   196

	if (!FileMD5(files->openttd)) {

   197

		add_pos += snprintf(add_pos, ERROR_MESSAGE_LENGTH, "Your '%s' file is corrupted or missing! The file was part of your installation.\n", files->openttd.filename);

   198

	}

   199

   200

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

   201

}

   202

   203

   204

static const SpriteID trg1idx[] = {

   205

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

   206

/* Medium font */

   207

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

   208

	SKIP,   36,

   209

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

   210

	  98,   98, ///< Up arrow

   211

	 131,  133,

   212

	SKIP,    1, ///< skip currency sign

   213

	 135,  135,

   214

	SKIP,    1,

   215

	 137,  137,

   216

	SKIP,    1,

   217

	 139,  139,

   218

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

   219

	 141,  141,

   220

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

   221

	 143,  143, ///< @todo Cross

   222

	 144,  144,

   223

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

   224

	 146,  149,

   225

	 118,  122, ///< Transport markers

   226

	SKIP,    2,

   227

	 157,  157,

   228

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

   229

	SKIP,    1,

   230

	 161,  225,

   231

/* Small font */

   232

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

   233

	SKIP,   36,

   234

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

   235

	 322,  322, ///< Up arrow

   236

	 355,  357,

   237

	SKIP,    1, ///< skip currency sign

   238

	 359,  359,

   239

	SKIP,    1,

   240

	 361,  361,

   241

	SKIP,    1,

   242

	 363,  363,

   243

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

   244

	 365,  366,

   245

	SKIP,    1,

   246

	 368,  368,

   247

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

   248

	 370,  373,

   249

	SKIP,    7,

   250

	 381,  381,

   251

	SKIP,    3,

   252

	 385,  449,

   253

/* Big font */

   254

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

   255

	SKIP,   36,

   256

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

   257

	SKIP,    1,

   258

	 579,  581,

   259

	SKIP,    1,

   260

	 583,  583,

   261

	SKIP,    5,

   262

	 589,  589,

   263

	SKIP,   15,

   264

	 605,  605,

   265

	SKIP,    3,

   266

	 609,  625,

   267

	SKIP,    1,

   268

	 627,  632,

   269

	SKIP,    1,

   270

	 634,  639,

   271

	SKIP,    1,

   272

	 641,  657,

   273

	SKIP,    1,

   274

	 659,  664,

   275

	SKIP,    2,

   276

	 667,  671,

   277

	SKIP,    1,

   278

	 673,  673,

   279

/* Graphics */

   280

	 674, 4792,

   281

	END

   282

};

   283

   284

/** Replace some letter sprites with some other letters */

   285

static const SpriteID _chars_grf_indexes[] = {

   286

	134, 134, ///<  euro symbol medium size

   287

	582, 582, ///<  euro symbol large size

   288

	358, 358, ///<  euro symbol tiny

   289

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

   290

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

   291

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

   292

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

   293

	382, 383, ///<  Œ œ tiny

   294

	158, 159, ///<  Œ œ medium

   295

	606, 607, ///<  Œ œ large

   296

	360, 360, ///<  Š tiny

   297

	362, 362, ///<  š tiny

   298

	136, 136, ///<  Š medium

   299

	138, 138, ///<  š medium

   300

	584, 584, ///<  Š large

   301

	586, 586, ///<  š large

   302

	626, 626, ///<  Ð large

   303

	658, 658, ///<  ð large

   304

	374, 374, ///<  Ž tiny

   305

	378, 378, ///<  ž tiny

   306

	150, 150, ///<  Ž medium

   307

	154, 154, ///<  ž medium

   308

	598, 598, ///<  Ž large

   309

	602, 602, ///<  ž large

   310

	640, 640, ///<  Þ large

   311

	672, 672, ///<  þ large

   312

	380, 380, ///<  º tiny

   313

	156, 156, ///<  º medium

   314

	604, 604, ///<  º large

   315

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

   316

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

   317

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

   318

	585, 585, ///<  § large

   319

	587, 587, ///<  © large

   320

	592, 592, ///<  ® large

   321

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

   322

	633, 633, ///<  × large

   323

	665, 665, ///<  ÷ large

   324

	377, 377, ///<  · small

   325

	153, 153, ///<  · medium

   326

	601, 601, ///<  · large

   327

	END

   328

};

   329

   330

   331

static void LoadSpriteTables()

   332

{

   333

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

   334

	uint i = FIRST_GRF_SLOT;

   335

   336

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

   337

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

   338

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

   339

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

   340

   341

	/*

   342

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

   343

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

   344

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

   345

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

   346

	 */

   347

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

   348

   349

	/*

   350

	 * Load additional sprites for climates other than temperate.

   351

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

   352

	 * and the ground sprites.

   353

	 */

   354

	if (_opt.landscape != LT_TEMPERATE) {

   355

		LoadGrfIndexed(

   356

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

   357

			_landscape_spriteindexes[_opt.landscape - 1],

   358

			i++

   359

		);

   360

	}

   361

   362

	LoadGrfIndexed(files->chars.filename, _chars_grf_indexes, i++);

   363

   364

	/* Initialize the unicode to sprite mapping table */

   365

	InitializeUnicodeGlyphMap();

   366

   367

	/*

   368

	 * Load the base NewGRF with OTTD required graphics as first NewGRF.

   369

	 * However, we do not want it to show up in the list of used NewGRFs,

   370

	 * so we have to manually add it, and then remove it later.

   371

	 */

   372

	GRFConfig *top = _grfconfig;

   373

	GRFConfig *master = CallocT<GRFConfig>(1);

   374

	master->filename = strdup(files->openttd.filename);

   375

	FillGRFDetails(master, false);

   376

	ClrBit(master->flags, GCF_INIT_ONLY);

   377

	master->next = top;

   378

	_grfconfig = master;

   379

   380

	LoadNewGRF(SPR_NEWGRFS_BASE, i);

   381

   382

	/* Free and remove the top element. */

   383

	ClearGRFConfig(&master);

   384

	_grfconfig = top;

   385

}

   386

   387

   388

void GfxLoadSprites()

   389

{

   390

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

   391

   392

	GfxInitSpriteMem();

   393

	LoadSpriteTables();

   394

	GfxInitPalettes();

   395

}