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

			usererror("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

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

    75

			assert(b);

    76

			(*sprite_id)++;

    77

		} while (++start <= end);

    78

	}

    79

}

    80

    81

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

    82

{

    83

	uint sprite_id = 0;

    84

    85

	FioOpenFile(file_index, filename);

    86

    87

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

    88

    89

	LoadSpritesIndexed(file_index, &sprite_id, index_tbl);

    90

}

    91

    92

    93

/**

    94

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

    95

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

    96

 * @return true if the checksum is correct.

    97

 */

    98

static bool FileMD5(const MD5File file)

    99

{

   100

	size_t size;

   101

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

   102

   103

	if (f != NULL) {

   104

		Md5 checksum;

   105

		uint8 buffer[1024];

   106

		uint8 digest[16];

   107

		size_t len;

   108

   109

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

   110

			size -= len;

   111

			checksum.Append(buffer, len);

   112

		}

   113

   114

		FioFCloseFile(f);

   115

   116

		checksum.Finish(digest);

   117

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

   118

	} else { // file not found

   119

		return false;

   120

	}

   121

}

   122

   123

/**

   124

 * Determine the palette that has to be used.

   125

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

   126

 *  - all Windows files present -> Windows palette

   127

 *  - all DOS files present -> DOS palette

   128

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

   129

 *  - otherwise -> Windows palette

   130

 */

   131

static void DeterminePalette()

   132

{

   133

	if (_use_dos_palette) return;

   134

   135

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

   136

	uint dos = 0;

   137

	uint win = 0;

   138

   139

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

   140

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

   141

   142

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

   143

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

   144

   145

	if (win == 5) {

   146

		_use_dos_palette = false;

   147

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

   148

		_use_dos_palette = true;

   149

	} else {

   150

		_use_dos_palette = false;

   151

	}

   152

}

   153

   154

/**

   155

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

   156

 *

   157

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

   158

 */

   159

void CheckExternalFiles()

   160

{

   161

	DeterminePalette();

   162

   163

	static const size_t ERROR_MESSAGE_LENGTH = 128;

   164

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

   165

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

   166

	error_msg[0] = '\0';

   167

	char *add_pos = error_msg;

   168

   169

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

   170

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

   171

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

   172

		}

   173

	}

   174

   175

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

   176

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

   177

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

   178

		}

   179

	}

   180

   181

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

   182

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

   183

	}

   184

   185

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

   186

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

   187

	}

   188

   189

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

   190

}

   191

   192

   193

static void LoadSpriteTables()

   194

{

   195

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

   196

	uint i = FIRST_GRF_SLOT;

   197

   198

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

   199

   200

	/*

   201

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

   202

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

   203

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

   204

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

   205

	 */

   206

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

   207

   208

	/*

   209

	 * Load additional sprites for climates other than temperate.

   210

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

   211

	 * and the ground sprites.

   212

	 */

   213

	if (_settings_game.game_creation.landscape != LT_TEMPERATE) {

   214

		LoadGrfIndexed(

   215

			files->landscape[_settings_game.game_creation.landscape - 1].filename,

   216

			_landscape_spriteindexes[_settings_game.game_creation.landscape - 1],

   217

			i++

   218

		);

   219

	}

   220

   221

	/* Initialize the unicode to sprite mapping table */

   222

	InitializeUnicodeGlyphMap();

   223

   224

	/*

   225

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

   226

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

   227

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

   228

	 */

   229

	GRFConfig *top = _grfconfig;

   230

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

   231

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

   232

	FillGRFDetails(master, false);

   233

	ClrBit(master->flags, GCF_INIT_ONLY);

   234

	master->next = top;

   235

	_grfconfig = master;

   236

   237

	LoadNewGRF(SPR_NEWGRFS_BASE, i);

   238

   239

	/* Free and remove the top element. */

   240

	ClearGRFConfig(&master);

   241

	_grfconfig = top;

   242

}

   243

   244

   245

void GfxLoadSprites()

   246

{

   247

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

   248

   249

	GfxInitSpriteMem();

   250

	LoadSpriteTables();

   251

	GfxInitPalettes();

   252

}