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

    15

#include "newgrf.h"

    16

#include "md5.h"

    17

#include "variables.h"

    18

#include "fontcache.h"

    19

#include <string.h>

    20

    21

struct MD5File {

    22

	const char * filename;     ///< filename

    23

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

    24

};

    25

    26

struct FileList {

    27

	MD5File basic[4];          ///< grf files that always have to be loaded

    28

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

    29

};

    30

    31

#include "table/files.h"

    32

#include "table/landscape_sprite.h"

    33

    34

static const SpriteID * const _landscape_spriteindexes[] = {

    35

	_landscape_spriteindexes_1,

    36

	_landscape_spriteindexes_2,

    37

	_landscape_spriteindexes_3,

    38

};

    39

    40

static const SpriteID * const _slopes_spriteindexes[] = {

    41

	_slopes_spriteindexes_0,

    42

	_slopes_spriteindexes_1,

    43

	_slopes_spriteindexes_2,

    44

	_slopes_spriteindexes_3,

    45

};

    46

    47

static const SpriteID * const _halftile_foundation_spriteindexes[] = {

    48

	_halftile_foundation_spriteindexes_0,

    49

	_halftile_foundation_spriteindexes_1,

    50

	_halftile_foundation_spriteindexes_2,

    51

	_halftile_foundation_spriteindexes_3,

    52

};

    53

    54

    55

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

    56

{

    57

	uint load_index_org = load_index;

    58

	uint sprite_id = 0;

    59

    60

	FioOpenFile(file_index, filename);

    61

    62

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

    63

    64

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

    65

		load_index++;

    66

		sprite_id++;

    67

		if (load_index >= MAX_SPRITES) {

    68

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

    69

		}

    70

	}

    71

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

    72

    73

	return load_index - load_index_org;

    74

}

    75

    76

   100

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

   101

{

   102

	uint sprite_id = 0;

   103

   104

	FioOpenFile(file_index, filename);

   105

   106

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

   107

   109

}

   110

   111

   112

/* Check that the supplied MD5 hash matches that stored for the supplied filename */

   113

static bool CheckMD5Digest(const MD5File file, md5_byte_t *digest, bool warn)

   114

{

   115

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

   116

	if (warn) fprintf(stderr, "MD5 of %s is ****INCORRECT**** - File Corrupt.\n", file.filename);

   117

	return false;

   118

}

   119

   120

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

   121

 * returns true if the checksum is correct */

   122

static bool FileMD5(const MD5File file, bool warn)

   123

{

   124

	size_t size;

   125

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

   126

   127

	if (f != NULL) {

   128

		md5_state_t filemd5state;

   129

		md5_byte_t buffer[1024];

   130

		md5_byte_t digest[16];

   131

		size_t len;

   132

   133

		md5_init(&filemd5state);

   134

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

   135

			size -= len;

   136

			md5_append(&filemd5state, buffer, len);

   137

		}

   138

   139

		if (ferror(f) && warn) ShowInfoF("Error Reading from %s \n", file.filename);

   140

		FioFCloseFile(f);

   141

   142

		md5_finish(&filemd5state, digest);

   143

		return CheckMD5Digest(file, digest, warn);

   144

	} else { // file not found

   145

		return false;

   146

	}

   147

}

   148

   149

/* Checks, if either the Windows files exist (TRG1R.GRF) or the DOS files (TRG1.GRF)

   150

 * by comparing the MD5 checksums of the files. _use_dos_palette is set accordingly.

   151

 * If neither are found, Windows palette is assumed.

   152

 *

   153

 * (Note: Also checks sample.cat for corruption) */

   154

void CheckExternalFiles()

   155

{

   156

	uint i;

   157

	/* count of files from this version */

   158

	uint dos = 0;

   159

	uint win = 0;

   160

   161

	for (i = 0; i < 2; i++) if (FileMD5(files_dos.basic[i], true)) dos++;

   162

	for (i = 0; i < 3; i++) if (FileMD5(files_dos.landscape[i], true)) dos++;

   163

   164

	for (i = 0; i < 2; i++) if (FileMD5(files_win.basic[i], true)) win++;

   165

	for (i = 0; i < 3; i++) if (FileMD5(files_win.landscape[i], true)) win++;

   166

   167

	if (!FileMD5(sample_cat_win, false) && !FileMD5(sample_cat_dos, false))

   168

		ShowInfo("Your 'sample.cat' file is corrupted or missing!");

   169

   170

	for (i = 0; i < lengthof(files_openttd); i++) {

   171

		if (!FileMD5(files_openttd[i], false)) {

   172

			ShowInfoF("Your '%s' file is corrupted or missing!", files_openttd[i].filename);

   173

		}

   174

	}

   175

   176

	/*

   177

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

   178

	 * all Windows files present -> Windows palette

   179

	 * all DOS files present -> DOS palette

   180

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

   181

	 * otherwise -> Windows palette

   182

	 */

   183

	if (_use_dos_palette) {

   184

		return;

   185

	} else if (win == 5) {

   186

		_use_dos_palette = false;

   187

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

   188

		_use_dos_palette = true;

   189

	} else {

   190

		_use_dos_palette = false;

   191

	}

   192

}

   193

   194

   195

static const SpriteID trg1idx[] = {

   196

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

   197

/* Medium font */

   198

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

   199

	SKIP,   36,

   200

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

   201

	  98,   98, ///< Up arrow

   202

	 131,  133,

   203

	SKIP,    1, ///< skip currency sign

   204

	 135,  135,

   205

	SKIP,    1,

   206

	 137,  137,

   207

	SKIP,    1,

   208

	 139,  139,

   209

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

   210

	 141,  141,

   211

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

   212

	 143,  143, ///< @todo Cross

   213

	 144,  144,

   214

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

   215

	 146,  149,

   216

	 118,  122, ///< Transport markers

   217

	SKIP,    2,

   218

	 157,  157,

   219

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

   220

	SKIP,    1,

   221

	 161,  225,

   222

/* Small font */

   223

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

   224

	SKIP,   36,

   225

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

   226

	 322,  322, ///< Up arrow

   227

	 355,  357,

   228

	SKIP,    1, ///< skip currency sign

   229

	 359,  359,

   230

	SKIP,    1,

   231

	 361,  361,

   232

	SKIP,    1,

   233

	 363,  363,

   234

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

   235

	 365,  366,

   236

	SKIP,    1,

   237

	 368,  368,

   238

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

   239

	 370,  373,

   240

	SKIP,    7,

   241

	 381,  381,

   242

	SKIP,    3,

   243

	 385,  449,

   244

/* Big font */

   245

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

   246

	SKIP,   36,

   247

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

   248

	SKIP,    1,

   249

	 579,  581,

   250

	SKIP,    1,

   251

	 583,  583,

   252

	SKIP,    5,

   253

	 589,  589,

   254

	SKIP,   15,

   255

	 605,  605,

   256

	SKIP,    3,

   257

	 609,  625,

   258

	SKIP,    1,

   259

	 627,  632,

   260

	SKIP,    1,

   261

	 634,  639,

   262

	SKIP,    1,

   263

	 641,  657,

   264

	SKIP,    1,

   265

	 659,  664,

   266

	SKIP,    2,

   267

	 667,  671,

   268

	SKIP,    1,

   269

	 673,  673,

   270

/* Graphics */

   271

	 674, 4792,

   272

	END

   273

};

   274

   275

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

   276

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

   277

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

   278

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

   279

 * a maximum use of sprite slots. */

   280

static const SpriteID _openttd_grf_indexes[] = {

   281

	SPR_IMG_AUTORAIL, SPR_CURSOR_WAYPOINT, // icons etc

   282

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

   283

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

   284

	358, 358,  ///<  euro symbol tiny

   285

	SPR_CURSOR_CANAL, SPR_IMG_FASTFORWARD, // more icons

   286

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

   287

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

   288

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

   289

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

   290

	SPR_PIN_UP, SPR_CURSOR_CLONE_TRAIN, // more icons

   291

	382, 383, ///<  Œ œ tiny

   292

	158, 159, ///<  Œ œ medium

   293

	606, 607, ///<  Œ œ large

   294

	360, 360, ///<  Š tiny

   295

	362, 362, ///<  š tiny

   296

	136, 136, ///<  Š medium

   297

	138, 138, ///<  š medium

   298

	584, 584, ///<  Š large

   299

	586, 586, ///<  š large

   300

	626, 626, ///<  Ð large

   301

	658, 658, ///<  ð large

   302

	374, 374, ///<  Ž tiny

   303

	378, 378, ///<  ž tiny

   304

	150, 150, ///<  Ž medium

   305

	154, 154, ///<  ž medium

   306

	598, 598, ///<  Ž large

   307

	602, 602, ///<  ž large

   308

	640, 640, ///<  Þ large

   309

	672, 672, ///<  þ large

   310

	380, 380, ///<  º tiny

   311

	156, 156, ///<  º medium

   312

	604, 604, ///<  º large

   313

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

   314

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

   315

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

   316

	SPR_HOUSE_ICON, SPR_HOUSE_ICON,

   317

	585, 585, ///<  § large

   318

	587, 587, ///<  © large

   319

	592, 592, ///<  ® large

   320

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

   321

	633, 633, ///<  × large

   322

	665, 665, ///<  ÷ large

   323

	SPR_SELL_TRAIN, SPR_SHARED_ORDERS_ICON,

   324

	377, 377, ///<  · small

   325

	153, 153, ///<  · medium

   326

	601, 601, ///<  · large

   327

	SPR_WARNING_SIGN, SPR_WARNING_SIGN,

   328

	END

   329

};

   330

   331

   332

static void LoadSpriteTables()

   333

{

   334

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

   335

	uint load_index;

   336

	uint i;

   337

   338

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

   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

	load_index = 4793;

   343

   344

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

   345

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

   346

	}

   347

   348

	/* Load additional sprites for climates other than temperate */

   349

	if (_opt.landscape != LT_TEMPERATE) {

   350

		LoadGrfIndexed(

   351

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

   352

			_landscape_spriteindexes[_opt.landscape - 1],

   353

			i++

   354

		);

   355

	}

   356

   357

	assert(load_index == SPR_SIGNALS_BASE);

   358

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

   359

   360

	assert(load_index == SPR_CANALS_BASE);

   361

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

   362

   363

	assert(load_index == SPR_SLOPES_BASE);

   364

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

   365

   366

	load_index = SPR_AUTORAIL_BASE;

   367

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

   368

   369

	assert(load_index == SPR_ELRAIL_BASE);

   370

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

   371

   372

	assert(load_index == SPR_2CCMAP_BASE);

   373

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

   374

   375

	assert(load_index == SPR_OPENTTD_BASE);

   376

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

   377

	load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT;

   378

   379

	assert(load_index == SPR_AIRPORTX_BASE);

   380

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

   381

   382

	assert(load_index == SPR_ROADSTOP_BASE);

   383

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

   384

   385

	assert(load_index == SPR_GROUP_BASE);

   386

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

   387

   388

	assert(load_index == SPR_TRAMWAY_BASE);

   389

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

   390

   391

	assert(load_index == SPR_ONEWAY_BASE);

   392

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

   393

   394

	load_index++; // SPR_EMPTY_BOUNDING_BOX

   395

   396

	assert(load_index == SPR_HALFTILE_FOUNDATION_BASE);

   397

	LoadGrfIndexed("halffndw.grf", _halftile_foundation_spriteindexes[_opt.landscape], i++);

   398

   399

	load_index = SPR_HALFTILE_SELECTION_BASE;

   400

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

   401

   402

	assert(load_index == SPR_FLAGS_BASE);

   403

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

   404

   405

	/* Initialize the unicode to sprite mapping table */

   406

	InitializeUnicodeGlyphMap();

   407

   408

	LoadNewGRF(load_index, i);

   409

}

   410

   411

   412

void GfxLoadSprites()

   413

{

   414

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

   415

   416

	GfxInitSpriteMem();

   417

	LoadSpriteTables();

   418

	GfxInitPalettes();

   419

}