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 "fileio.h"

    11

#include "fios.h"

    12

#include "newgrf.h"

    13

#include "md5.h"

    14

#include "variables.h"

    15

#include "fontcache.h"

    16

#include "gfx_func.h"

    17

#include "core/alloc_func.hpp"

    18

#include "core/bitmath_func.hpp"

    19

#include <string.h>

    20

#include "settings_type.h"

    21

    22

#include "table/sprites.h"

    23

    24

struct MD5File {

    25

	const char * filename;     ///< filename

    26

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

    27

};

    28

    29

struct FileList {

    30

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

    31

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

    32

	MD5File sound;        ///< Sound samples

    33

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

    34

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

    35

};

    36

    37

#include "table/files.h"

    38

#include "table/landscape_sprite.h"

    39

    40

static const SpriteID * const _landscape_spriteindexes[] = {

    41

	_landscape_spriteindexes_1,

    42

	_landscape_spriteindexes_2,

    43

	_landscape_spriteindexes_3,

    44

};

    45

    46

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

    47

{

    48

	uint load_index_org = load_index;

    49

	uint sprite_id = 0;

    50

    51

	FioOpenFile(file_index, filename);

    52

    53

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

    54

    55

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

    56

		load_index++;

    57

		sprite_id++;

    58

		if (load_index >= MAX_SPRITES) {

    59

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

    60

		}

    61

	}

    62

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

    63

    64

	return load_index - load_index_org;

    65

}

    66

    67

    68

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

    69

{

    70

	uint start;

    71

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

    72

		uint end = *index_tbl++;

    73

    74

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

    75

			SkipSprites(end);

    76

			(*sprite_id) += end;

    77

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

    78

			do {

    79

			#ifdef NDEBUG

    80

				LoadNextSprite(start, file_index, *sprite_id);

    81

			#else

    82

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

    83

				assert(b);

    84

			#endif

    85

				(*sprite_id)++;

    86

			} while (++start <= end);

    87

		}

    88

	}

    89

}

    90

    91

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

    92

{

    93

	uint sprite_id = 0;

    94

    95

	FioOpenFile(file_index, filename);

    96

    97

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

    98

    99

	LoadSpritesIndexed(file_index, &sprite_id, index_tbl);

   100

}

   101

   102

   103

/**

   104

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

   105

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

   106

 * @return true if the checksum is correct.

   107

 */

   108

static bool FileMD5(const MD5File file)

   109

{

   110

	size_t size;

   111

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

   112

   113

	if (f != NULL) {

   114

		Md5 checksum;

   115

		uint8 buffer[1024];

   116

		uint8 digest[16];

   117

		size_t len;

   118

   119

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

   120

			size -= len;

   121

			checksum.Append(buffer, len);

   122

		}

   123

   124

		FioFCloseFile(f);

   125

   126

		checksum.Finish(digest);

   127

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

   128

	} else { // file not found

   129

		return false;

   130

	}

   131

}

   132

   133

/**

   134

 * Determine the palette that has to be used.

   135

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

   136

 *  - all Windows files present -> Windows palette

   137

 *  - all DOS files present -> DOS palette

   138

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

   139

 *  - otherwise -> Windows palette

   140

 */

   141

static void DeterminePalette()

   142

{

   143

	if (_use_dos_palette) return;

   144

   145

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

   146

	uint dos = 0;

   147

	uint win = 0;

   148

   149

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

   150

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

   151

   152

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

   153

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

   154

   155

	if (win == 5) {

   156

		_use_dos_palette = false;

   157

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

   158

		_use_dos_palette = true;

   159

	} else {

   160

		_use_dos_palette = false;

   161

	}

   162

}

   163

   164

/**

   165

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

   166

 *

   167

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

   168

 */

   169

void CheckExternalFiles()

   170

{

   171

	DeterminePalette();

   172

   173

	static const size_t ERROR_MESSAGE_LENGTH = 128;

   174

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

   175

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

   176

	error_msg[0] = '\0';

   177

	char *add_pos = error_msg;

   178

   179

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

   180

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

   181

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

   182

		}

   183

	}

   184

   185

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

   186

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

   187

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

   188

		}

   189

	}

   190

   191

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

   192

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

   193

	}

   194

   195

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

   196

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

   197

	}

   198

   199

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

   200

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

   201

	}

   202

   203

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

   204

}

   205

   206

   207

static const SpriteID trg1idx[] = {

   208

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

   209

/* Medium font */

   210

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

   211

	SKIP,   36,

   212

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

   213

	  98,   98, ///< Up arrow

   214

	 131,  133,

   215

	SKIP,    1, ///< skip currency sign

   216

	 135,  135,

   217

	SKIP,    1,

   218

	 137,  137,

   219

	SKIP,    1,

   220

	 139,  139,

   221

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

   222

	 141,  141,

   223

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

   224

	 143,  143, ///< @todo Cross

   225

	 144,  144,

   226

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

   227

	 146,  149,

   228

	 118,  122, ///< Transport markers

   229

	SKIP,    2,

   230

	 157,  157,

   231

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

   232

	SKIP,    1,

   233

	 161,  225,

   234

/* Small font */

   235

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

   236

	SKIP,   36,

   237

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

   238

	 322,  322, ///< Up arrow

   239

	 355,  357,

   240

	SKIP,    1, ///< skip currency sign

   241

	 359,  359,

   242

	SKIP,    1,

   243

	 361,  361,

   244

	SKIP,    1,

   245

	 363,  363,

   246

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

   247

	 365,  366,

   248

	SKIP,    1,

   249

	 368,  368,

   250

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

   251

	 370,  373,

   252

	SKIP,    7,

   253

	 381,  381,

   254

	SKIP,    3,

   255

	 385,  449,

   256

/* Big font */

   257

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

   258

	SKIP,   36,

   259

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

   260

	SKIP,    1,

   261

	 579,  581,

   262

	SKIP,    1,

   263

	 583,  583,

   264

	SKIP,    5,

   265

	 589,  589,

   266

	SKIP,   15,

   267

	 605,  605,

   268

	SKIP,    3,

   269

	 609,  625,

   270

	SKIP,    1,

   271

	 627,  632,

   272

	SKIP,    1,

   273

	 634,  639,

   274

	SKIP,    1,

   275

	 641,  657,

   276

	SKIP,    1,

   277

	 659,  664,

   278

	SKIP,    2,

   279

	 667,  671,

   280

	SKIP,    1,

   281

	 673,  673,

   282

/* Graphics */

   283

	 674, 4792,

   284

	END

   285

};

   286

   287

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

   288

static const SpriteID _chars_grf_indexes[] = {

   289

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

   290

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

   291

	358, 358, ///<  euro symbol tiny

   292

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

   293

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

   294

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

   295

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

   296

	382, 383, ///<  Œ œ tiny

   297

	158, 159, ///<  Œ œ medium

   298

	606, 607, ///<  Œ œ large

   299

	360, 360, ///<  Š tiny

   300

	362, 362, ///<  š tiny

   301

	136, 136, ///<  Š medium

   302

	138, 138, ///<  š medium

   303

	584, 584, ///<  Š large

   304

	586, 586, ///<  š large

   305

	626, 626, ///<  Ð large

   306

	658, 658, ///<  ð large

   307

	374, 374, ///<  Ž tiny

   308

	378, 378, ///<  ž tiny

   309

	150, 150, ///<  Ž medium

   310

	154, 154, ///<  ž medium

   311

	598, 598, ///<  Ž large

   312

	602, 602, ///<  ž large

   313

	640, 640, ///<  Þ large

   314

	672, 672, ///<  þ large

   315

	380, 380, ///<  º tiny

   316

	156, 156, ///<  º medium

   317

	604, 604, ///<  º large

   318

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

   319

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

   320

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

   321

	585, 585, ///<  § large

   322

	587, 587, ///<  © large

   323

	592, 592, ///<  ® large

   324

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

   325

	633, 633, ///<  × large

   326

	665, 665, ///<  ÷ large

   327

	377, 377, ///<  · small

   328

	153, 153, ///<  · medium

   329

	601, 601, ///<  · large

   330

	END

   331

};

   332

   333

   334

static void LoadSpriteTables()

   335

{

   336

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

   337

	uint i = FIRST_GRF_SLOT;

   338

   339

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

   340

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

   341

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

   342

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

   343

   344

	/*

   345

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

   346

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

   347

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

   348

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

   349

	 */

   350

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

   351

   352

	/*

   353

	 * Load additional sprites for climates other than temperate.

   354

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

   355

	 * and the ground sprites.

   356

	 */

   357

	if (_opt.landscape != LT_TEMPERATE) {

   358

		LoadGrfIndexed(

   359

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

   360

			_landscape_spriteindexes[_opt.landscape - 1],

   361

			i++

   362

		);

   363

	}

   364

   365

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

   366

   367

	/* Initialize the unicode to sprite mapping table */

   368

	InitializeUnicodeGlyphMap();

   369

   370

	/*

   371

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

   372

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

   373

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

   374

	 */

   375

	GRFConfig *top = _grfconfig;

   376

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

   377

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

   378

	FillGRFDetails(master, false);

   379

	ClrBit(master->flags, GCF_INIT_ONLY);

   380

	master->next = top;

   381

	_grfconfig = master;

   382

   383

	LoadNewGRF(SPR_NEWGRFS_BASE, i);

   384

   385

	/* Free and remove the top element. */

   386

	ClearGRFConfig(&master);

   387

	_grfconfig = top;

   388

}

   389

   390

   391

void GfxLoadSprites()

   392

{

   393

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

   394

   395

	GfxInitSpriteMem();

   396

	LoadSpriteTables();

   397

	GfxInitPalettes();

   398

}