1

/* $Id$ */

     2

     3

/** @file gfxinit.cpp Initializing of the (GRF) graphics. */

     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

		do {

    74

		#ifdef NDEBUG

    75

			LoadNextSprite(start, file_index, *sprite_id);

    76

		#else

    77

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

    78

			assert(b);

    79

		#endif

    80

			(*sprite_id)++;

    81

		} while (++start <= end);

    82

	}

    83

}

    84

    85

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

    86

{

    87

	uint sprite_id = 0;

    88

    89

	FioOpenFile(file_index, filename);

    90

    91

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

    92

    93

	LoadSpritesIndexed(file_index, &sprite_id, index_tbl);

    94

}

    95

    96

    97

/**

    98

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

    99

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

   100

 * @return true if the checksum is correct.

   101

 */

   102

static bool FileMD5(const MD5File file)

   103

{

   104

	size_t size;

   105

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

   106

   107

	if (f != NULL) {

   108

		Md5 checksum;

   109

		uint8 buffer[1024];

   110

		uint8 digest[16];

   111

		size_t len;

   112

   113

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

   114

			size -= len;

   115

			checksum.Append(buffer, len);

   116

		}

   117

   118

		FioFCloseFile(f);

   119

   120

		checksum.Finish(digest);

   121

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

   122

	} else { // file not found

   123

		return false;

   124

	}

   125

}

   126

   127

/**

   128

 * Determine the palette that has to be used.

   129

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

   130

 *  - all Windows files present -> Windows palette

   131

 *  - all DOS files present -> DOS palette

   132

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

   133

 *  - otherwise -> Windows palette

   134

 */

   135

static void DeterminePalette()

   136

{

   137

	if (_use_dos_palette) return;

   138

   139

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

   140

	uint dos = 0;

   141

	uint win = 0;

   142

   143

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

   144

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

   145

   146

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

   147

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

   148

   149

	if (win == 5) {

   150

		_use_dos_palette = false;

   151

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

   152

		_use_dos_palette = true;

   153

	} else {

   154

		_use_dos_palette = false;

   155

	}

   156

}

   157

   158

/**

   159

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

   160

 *

   161

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

   162

 */

   163

void CheckExternalFiles()

   164

{

   165

	DeterminePalette();

   166

   167

	static const size_t ERROR_MESSAGE_LENGTH = 128;

   168

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

   169

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

   170

	error_msg[0] = '\0';

   171

	char *add_pos = error_msg;

   172

   173

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

   174

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

   175

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

   176

		}

   177

	}

   178

   179

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

   180

		if (!FileMD5(files->landscape[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->landscape[i].filename, files->landscape[i].filename);

   182

		}

   183

	}

   184

   185

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

   186

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

   187

	}

   188

   189

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

   190

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

   191

	}

   192

   193

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

   194

}

   195

   196

   197

static void LoadSpriteTables()

   198

{

   199

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

   200

	uint i = FIRST_GRF_SLOT;

   201

   202

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

   203

   204

	/*

   205

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

   206

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

   207

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

   208

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

   209

	 */

   210

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

   211

   212

	/*

   213

	 * Load additional sprites for climates other than temperate.

   214

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

   215

	 * and the ground sprites.

   216

	 */

   218

		LoadGrfIndexed(

   221

			i++

   222

		);

   223

	}

   224

   225

	/* Initialize the unicode to sprite mapping table */

   226

	InitializeUnicodeGlyphMap();

   227

   228

	/*

   229

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

   230

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

   231

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

   232

	 */

   233

	GRFConfig *top = _grfconfig;

   234

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

   235

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

   236

	FillGRFDetails(master, false);

   237

	ClrBit(master->flags, GCF_INIT_ONLY);

   238

	master->next = top;

   239

	_grfconfig = master;

   240

   241

	LoadNewGRF(SPR_NEWGRFS_BASE, i);

   242

   243

	/* Free and remove the top element. */

   244

	ClearGRFConfig(&master);

   245

	_grfconfig = top;

   246

}

   247

   248

   249

void GfxLoadSprites()

   250

{

   252

   253

	GfxInitSpriteMem();

   254

	LoadSpriteTables();

   255

	GfxInitPalettes();

   256

}