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 openttd;      ///< GRF File with OTTD specific graphics

    34

};

    35

    36

#include "table/files.h"

    37

#include "table/landscape_sprite.h"

    38

    39

static const SpriteID * const _landscape_spriteindexes[] = {

    40

	_landscape_spriteindexes_1,

    41

	_landscape_spriteindexes_2,

    42

	_landscape_spriteindexes_3,

    43

};

    44

    45

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

    46

{

    47

	uint load_index_org = load_index;

    48

	uint sprite_id = 0;

    49

    50

	FioOpenFile(file_index, filename);

    51

    52

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

    53

    54

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

    55

		load_index++;

    56

		sprite_id++;

    57

		if (load_index >= MAX_SPRITES) {

    58

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

    59

		}

    60

	}

    61

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

    62

    63

	return load_index - load_index_org;

    64

}

    65

    66

    67

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

    68

{

    69

	uint start;

    70

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

    71

		uint end = *index_tbl++;

    72

    73

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

    74

			SkipSprites(end);

    75

			(*sprite_id) += end;

    76

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

    77

			do {

    78

			#ifdef NDEBUG

    79

				LoadNextSprite(start, file_index, *sprite_id);

    80

			#else

    81

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

    82

				assert(b);

    83

			#endif

    84

				(*sprite_id)++;

    85

			} while (++start <= end);

    86

		}

    87

	}

    88

}

    89

    90

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

    91

{

    92

	uint sprite_id = 0;

    93

    94

	FioOpenFile(file_index, filename);

    95

    96

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

    97

    98

	LoadSpritesIndexed(file_index, &sprite_id, index_tbl);

    99

}

   100

   101

   102

/**

   103

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

   104

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

   105

 * @return true if the checksum is correct.

   106

 */

   107

static bool FileMD5(const MD5File file)

   108

{

   109

	size_t size;

   110

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

   111

   112

	if (f != NULL) {

   113

		Md5 checksum;

   114

		uint8 buffer[1024];

   115

		uint8 digest[16];

   116

		size_t len;

   117

   118

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

   119

			size -= len;

   120

			checksum.Append(buffer, len);

   121

		}

   122

   123

		FioFCloseFile(f);

   124

   125

		checksum.Finish(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;

   174

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

   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

   190

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

   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

   194

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

   195

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

   196

	}

   197

   198

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

   199

}

   200

   201

   202

static const SpriteID trg1idx[] = {

   203

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

   204

/* Medium font */

   205

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

   206

	SKIP,   36,

   207

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

   208

	  98,   98, ///< Up arrow

   209

	 131,  133,

   210

	SKIP,    1, ///< skip currency sign

   211

	 135,  135,

   212

	SKIP,    1,

   213

	 137,  137,

   214

	SKIP,    1,

   215

	 139,  139,

   216

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

   217

	 141,  141,

   218

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

   219

	 143,  143, ///< @todo Cross

   220

	 144,  144,

   221

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

   222

	 146,  149,

   223

	 118,  122, ///< Transport markers

   224

	SKIP,    2,

   225

	 157,  157,

   226

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

   227

	SKIP,    1,

   228

	 161,  225,

   229

/* Small font */

   230

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

   231

	SKIP,   36,

   232

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

   233

	 322,  322, ///< Up arrow

   234

	 355,  357,

   235

	SKIP,    1, ///< skip currency sign

   236

	 359,  359,

   237

	SKIP,    1,

   238

	 361,  361,

   239

	SKIP,    1,

   240

	 363,  363,

   241

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

   242

	 365,  366,

   243

	SKIP,    1,

   244

	 368,  368,

   245

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

   246

	 370,  373,

   247

	SKIP,    7,

   248

	 381,  381,

   249

	SKIP,    3,

   250

	 385,  449,

   251

/* Big font */

   252

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

   253

	SKIP,   36,

   254

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

   255

	SKIP,    1,

   256

	 579,  581,

   257

	SKIP,    1,

   258

	 583,  583,

   259

	SKIP,    5,

   260

	 589,  589,

   261

	SKIP,   15,

   262

	 605,  605,

   263

	SKIP,    3,

   264

	 609,  625,

   265

	SKIP,    1,

   266

	 627,  632,

   267

	SKIP,    1,

   268

	 634,  639,

   269

	SKIP,    1,

   270

	 641,  657,

   271

	SKIP,    1,

   272

	 659,  664,

   273

	SKIP,    2,

   274

	 667,  671,

   275

	SKIP,    1,

   276

	 673,  673,

   277

/* Graphics */

   278

	 674, 4792,

   279

	END

   280

};

   281

   282

static void LoadSpriteTables()

   283

{

   284

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

   285

	uint i = FIRST_GRF_SLOT;

   286

   287

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

   288

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

   289

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

   290

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

   291

   292

	/*

   293

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

   294

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

   295

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

   296

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

   297

	 */

   298

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

   299

   300

	/*

   301

	 * Load additional sprites for climates other than temperate.

   302

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

   303

	 * and the ground sprites.

   304

	 */

   305

	if (_opt.landscape != LT_TEMPERATE) {

   306

		LoadGrfIndexed(

   307

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

   308

			_landscape_spriteindexes[_opt.landscape - 1],

   309

			i++

   310

		);

   311

	}

   312

   313

	/* Initialize the unicode to sprite mapping table */

   314

	InitializeUnicodeGlyphMap();

   315

   316

	/*

   317

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

   318

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

   319

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

   320

	 */

   321

	GRFConfig *top = _grfconfig;

   322

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

   323

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

   324

	FillGRFDetails(master, false);

   325

	ClrBit(master->flags, GCF_INIT_ONLY);

   326

	master->next = top;

   327

	_grfconfig = master;

   328

   329

	LoadNewGRF(SPR_NEWGRFS_BASE, i);

   330

   331

	/* Free and remove the top element. */

   332

	ClearGRFConfig(&master);

   333

	_grfconfig = top;

   334

}

   335

   336

   337

void GfxLoadSprites()

   338

{

   339

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

   340

   341

	GfxInitSpriteMem();

   342

	LoadSpriteTables();

   343

	GfxInitPalettes();

   344

}