1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "hal.h"

     5

     6

#include <dirent.h>

     7

#include <unistd.h>

     8

#include <sys/stat.h>

     9

#include <time.h>

    10

#include <pwd.h>

    11

    12

#if defined(__linux__)

    13

#include <sys/statvfs.h>

    14

#endif

    15

    16

    17

#if defined(WITH_SDL)

    18

#include <SDL.h>

    19

#endif

    20

    21

#ifdef __MORPHOS__

    22

#include <exec/types.h>

    23

ULONG __stack = (1024*1024)*2; // maybe not that much is needed actually ;)

    24

#endif /* __MORPHOS__ */

    25

    26

static char *_fios_path;

    27

static char *_fios_save_path;

    28

static char *_fios_scn_path;

    29

static FiosItem *_fios_items;

    30

static int _fios_count, _fios_alloc;

    31

    32

static FiosItem *FiosAlloc()

    33

{

    34

	if (_fios_count == _fios_alloc) {

    35

		_fios_alloc += 256;

    36

		_fios_items = realloc(_fios_items, _fios_alloc * sizeof(FiosItem));

    37

	}

    38

	return &_fios_items[_fios_count++];

    39

}

    40

    41

int compare_FiosItems (const void *a, const void *b) {

    42

	const FiosItem *da = (const FiosItem *) a;

    43

	const FiosItem *db = (const FiosItem *) b;

    44

	int r;

    45

    46

	if (_savegame_sort_order < 2) // sort by date

    47

    r = da->mtime < db->mtime ? -1 : 1;

    48

	else

    49

		r = strcasecmp(da->title[0] ? da->title : da->name, db->title[0] ? db->title : db->name);

    50

    51

	if (_savegame_sort_order & 1) r = -r;

    52

	return r;

    53

}

    54

    55

    56

// Get a list of savegames

    57

FiosItem *FiosGetSavegameList(int *num, int mode)

    58

{

    59

	FiosItem *fios;

    60

	DIR *dir;

    61

	struct dirent *dirent;

    62

	struct stat sb;

    63

	int sort_start;

    64

	char filename[MAX_PATH];

    65

    66

	if (_fios_save_path == NULL) {

    67

		_fios_save_path = malloc(MAX_PATH);

    68

		strcpy(_fios_save_path, _path.save_dir);

    69

	}

    70

    71

	if(_game_mode==GM_EDITOR)

    72

		_fios_path = _fios_scn_path;

    73

	else

    74

		_fios_path = _fios_save_path;

    75

    76

	// Parent directory, only if not in root already.

    77

	if (_fios_path[1] != 0) {

    78

		fios = FiosAlloc();

    79

		fios->type = FIOS_TYPE_PARENT;

    80

		fios->mtime = 0;

    81

		sprintf(fios->title, ".. (Parent directory)");

    82

	}

    83

    84

	// Show subdirectories first

    85

	dir = opendir(_fios_path[0] ? _fios_path : "/");

    86

	if (dir != NULL) {

    87

		while ((dirent = readdir(dir))) {

    88

			sprintf (filename, "%s/%s", _fios_path, dirent->d_name);

    89

			if (!stat(filename, &sb)) {

    90

				if (S_ISDIR(sb.st_mode)) {

    91

					if (dirent->d_name[0] != '.') {

    92

						fios = FiosAlloc();

    93

						fios->mtime = 0;

    94

						fios->type = FIOS_TYPE_DIR;

    95

						fios->title[0] = 0;

    96

						sprintf(fios->name, "%s/ (Directory)", dirent->d_name);

    97

					}

    98

				}

    99

			}

   100

		}

   101

		closedir(dir);

   102

	}

   103

   104

	{

   105

		/* XXX ugly global variables ... */

   106

		byte order = _savegame_sort_order;

   107

		_savegame_sort_order = 2; // sort ascending by name

   108

		qsort(_fios_items, _fios_count, sizeof(FiosItem), compare_FiosItems);

   109

		_savegame_sort_order = order;

   110

	}

   111

   112

	// this is where to start sorting

   113

	sort_start = _fios_count;

   114

   115

	/*	Show savegame files

   116

	 *	.SAV	OpenTTD saved game

   117

	 *	.SS1	Transport Tycoon Deluxe preset game

   118

	 *	.SV1	Transport Tycoon Deluxe (Patch) saved game

   119

	 *	.SV2	Transport Tycoon Deluxe (Patch) saved 2-player game

   120

	 */

   121

	dir = opendir(_fios_path[0] ? _fios_path : "/");

   122

	if (dir != NULL) {

   123

		while ((dirent = readdir(dir))) {

   124

			sprintf (filename, "%s/%s", _fios_path, dirent->d_name);

   125

			if (!stat(filename, &sb)) {

   126

				if (!S_ISDIR(sb.st_mode)) {

   127

					char *t = strrchr(dirent->d_name, '.');

   128

					if (t && !strcasecmp(t, ".sav")) { // OpenTTD

   129

						*t = 0; // cut extension

   130

						fios = FiosAlloc();

   131

						fios->type = FIOS_TYPE_FILE;

   132

						fios->mtime = sb.st_mtime;

   133

						fios->title[0] = 0;

   134

						ttd_strlcpy(fios->name, dirent->d_name, sizeof(fios->name));

   135

					} else if (mode == SLD_LOAD_GAME || mode == SLD_LOAD_SCENARIO) {

   136

						int ext = 0; // start of savegame extensions in _old_extensions[]

   137

						if (t && ((ext++, !strcasecmp(t, ".ss1")) || (ext++, !strcasecmp(t, ".sv1")) || (ext++, !strcasecmp(t, ".sv2"))) ) { // TTDLX(Patch)

   138

							*t = 0; // cut extension

   139

							fios = FiosAlloc();

   140

							fios->old_extension = ext-1;

   141

							fios->type = FIOS_TYPE_OLDFILE;

   142

							fios->mtime = sb.st_mtime;

   143

							ttd_strlcpy(fios->name, dirent->d_name, sizeof(fios->name));

   144

							GetOldSaveGameName(fios->title, filename);

   145

						}

   146

					}

   147

				}

   148

			}

   149

		}

   150

		closedir(dir);

   151

	}

   152

   153

	*num = _fios_count;

   154

	qsort(_fios_items + sort_start, _fios_count - sort_start, sizeof(FiosItem), compare_FiosItems);

   155

	return _fios_items;

   156

}

   157

   158

// Get a list of scenarios

   159

FiosItem *FiosGetScenarioList(int *num, int mode)

   160

{

   161

	FiosItem *fios;

   162

	DIR *dir;

   163

	struct dirent *dirent;

   164

	struct stat sb;

   165

	int sort_start;

   166

	char filename[MAX_PATH];

   167

   168

	if (_fios_scn_path == NULL) {

   169

		_fios_scn_path = malloc(MAX_PATH);

   170

		strcpy(_fios_scn_path, _path.scenario_dir);

   171

	}

   172

	_fios_path = _fios_scn_path;

   173

   174

	// Show subdirectories first

   175

	dir = opendir(_fios_path[0] ? _fios_path : "/");

   176

	if (dir != NULL) {

   177

		while ((dirent = readdir(dir))) {

   178

			sprintf (filename, "%s/%s", _fios_path, dirent->d_name);

   179

			if (!stat(filename, &sb)) {

   180

				if (S_ISDIR(sb.st_mode)) {

   181

					if (dirent->d_name[0] != '.') {

   182

						fios = FiosAlloc();

   183

						fios->mtime = 0;

   184

						fios->type = FIOS_TYPE_DIR;

   185

						fios->title[0] = 0;

   186

						sprintf(fios->name, "%s/ (Directory)", dirent->d_name);

   187

					}

   188

				}

   189

			}

   190

		}

   191

		closedir(dir);

   192

	}

   193

   194

	// this is where to start sorting

   195

	sort_start = _fios_count;

   196

   197

	/*	Show scenario files

   198

	 *	.SCN	OpenTTD style scenario file

   199

	 *	.SV0	Transport Tycoon Deluxe (Patch) scenario

   200

	 *	.SS0	Transport Tycoon Deluxe preset scenario

   201

	 */

   202

	dir = opendir(_fios_path[0] ? _fios_path : "/");

   203

	if (dir != NULL) {

   204

		while ((dirent = readdir(dir))) {

   205

			sprintf (filename, "%s/%s", _fios_path, dirent->d_name);

   206

			if (!stat(filename, &sb)) {

   207

				if (!S_ISDIR(sb.st_mode)) {

   208

					char *t = strrchr(dirent->d_name, '.');

   209

					if (t && !strcasecmp(t, ".scn")) { // OpenTTD

   210

						*t = 0; // cut extension

   211

						fios = FiosAlloc();

   212

						fios->type = FIOS_TYPE_SCENARIO;

   213

						fios->mtime = sb.st_mtime;

   214

						fios->title[0] = 0;

   215

						ttd_strlcpy(fios->name, dirent->d_name, sizeof(fios->name)-3);

   216

					} else if (mode == SLD_LOAD_GAME || mode == SLD_LOAD_SCENARIO || mode == SLD_NEW_GAME) {

   217

						int ext = 3; // start of scenario extensions in _old_extensions[]

   218

						if (t && ((ext++, !strcasecmp(t, ".sv0")) || (ext++, !strcasecmp(t, ".ss0"))) ) { // TTDLX(Patch)

   219

							*t = 0; // cut extension

   220

							fios = FiosAlloc();

   221

							fios->old_extension = ext-1;

   222

							fios->type = FIOS_TYPE_OLD_SCENARIO;

   223

							fios->mtime = sb.st_mtime;

   224

							GetOldScenarioGameName(fios->title, filename);

   225

							ttd_strlcpy(fios->name, dirent->d_name, sizeof(fios->name)-3);

   226

						}

   227

					}

   228

				}

   229

			}

   230

		}

   231

		closedir(dir);

   232

	}

   233

   234

	*num = _fios_count;

   235

	qsort(_fios_items + sort_start, _fios_count - sort_start, sizeof(FiosItem), compare_FiosItems);

   236

	return _fios_items;

   237

}

   238

   239

   240

// Free the list of savegames

   241

void FiosFreeSavegameList()

   242

{

   243

	free(_fios_items);

   244

	_fios_items = NULL;

   245

	_fios_alloc = _fios_count = 0;

   246

}

   247

   248

// Browse to

   249

char *FiosBrowseTo(const FiosItem *item)

   250

{

   251

	char *path = _fios_path;

   252

	char *s;

   253

   254

	switch(item->type) {

   255

	case FIOS_TYPE_PARENT:

   256

		s = strrchr(path, '/');

   257

		if (s != NULL) *s = 0;

   258

		break;

   259

   260

	case FIOS_TYPE_DIR:

   261

		s = strchr((char*)item->name, '/');

   262

		if (s) *s = 0;

   263

		while (*path) path++;

   264

		*path++ = '/';

   265

		strcpy(path, item->name);

   266

		break;

   267

   268

	case FIOS_TYPE_FILE:

   269

		FiosMakeSavegameName(str_buffr, item->name);

   270

		return str_buffr;

   271

   272

	case FIOS_TYPE_OLDFILE:

   273

		sprintf(str_buffr, "%s/%s.%s", _fios_path, item->name, _old_extensions[item->old_extension]);

   274

		return str_buffr;

   275

   276

	case FIOS_TYPE_SCENARIO:

   277

		sprintf(str_buffr, "%s/%s.scn", path, item->name);

   278

		return str_buffr;

   279

   280

	case FIOS_TYPE_OLD_SCENARIO:

   281

		sprintf(str_buffr, "%s/%s.%s", path, item->name, _old_extensions[item->old_extension]);

   282

		return str_buffr;

   283

	}

   284

   285

	return NULL;

   286

}

   287

   288

// Get descriptive texts.

   289

// Returns a path as well as a

   290

//  string describing the path.

   291

StringID FiosGetDescText(const char **path)

   292

{

   293

	*path = _fios_path[0] ? _fios_path : "/";

   294

   295

#if defined(__linux__)

   296

	{

   297

	struct statvfs s;

   298

   299

	if (statvfs(*path, &s) == 0)

   300

	{

   301

		uint64 tot = (uint64)s.f_bsize * s.f_bavail;

   302

		SetDParam(0, (uint32)(tot >> 20));

   303

		return STR_4005_BYTES_FREE;

   304

	}

   305

	else

   306

		return STR_4006_UNABLE_TO_READ_DRIVE;

   307

	}

   308

#else

   309

	SetDParam(0, 0);

   310

	return STR_4005_BYTES_FREE;

   311

#endif

   312

}

   313

   314

void FiosMakeSavegameName(char *buf, const char *name)

   315

{

   316

	if(_game_mode==GM_EDITOR)

   317

		sprintf(buf, "%s/%s.scn", _fios_path, name);

   318

	else

   319

		sprintf(buf, "%s/%s.sav", _fios_path, name);

   320

}

   321

   322

void FiosDelete(const char *name)

   323

{

   324

	char *path = str_buffr;

   325

	FiosMakeSavegameName(path, name);

   326

	unlink(path);

   327

}

   328

   329

const DriverDesc _video_driver_descs[] = {

   330

	{"null",	"Null Video Driver",	&_null_video_driver,	0},

   331

#if defined(WITH_SDL)

   332

	{ "sdl",	"SDL Video Driver",		&_sdl_video_driver,		1},

   333

#endif

   334

	{ "dedicated", "Dedicated Video Driver", &_dedicated_video_driver, 0},

   335

	{ NULL,		NULL,									NULL,									0}

   336

};

   337

   338

const DriverDesc _sound_driver_descs[] = {

   339

	{"null",	"Null Sound Driver",	&_null_sound_driver,		0},

   340

#if defined(WITH_SDL)

   341

	{ "sdl",	"SDL Sound Driver",		&_sdl_sound_driver,			1},

   342

#endif

   343

	{ NULL,		NULL,									NULL,										0}

   344

};

   345

   346

#if defined(__APPLE__)

   347

#define EXTMIDI_PRI 2

   348

#else

   349

#define EXTMIDI_PRI 0

   350

#endif

   351

   352

const DriverDesc _music_driver_descs[] = {

   353

#ifndef __BEOS__

   356

	{"extmidi",	"External MIDI Driver",	&_extmidi_music_driver,	EXTMIDI_PRI},

   357

#endif

   358

#endif

   359

#ifdef __BEOS__

   360

	{ "bemidi",	"BeOS MIDI Driver",			&_bemidi_music_driver,	1},

   361

#endif

   362

	{   "null",	"Null Music Driver",		&_null_music_driver,		1},

   363

	{     NULL,	NULL,										NULL,										0}

   364

};

   365

   366

/* GetOSVersion returns the minimal required version of OS to be able to use that driver.

   367

	 Not needed for *nix. */

   368

byte GetOSVersion()

   369

{

   370

	return 2;  // any arbitrary number bigger then 0

   371

				// numbers lower than 2 breaks default music selection on mac

   372

}

   373

   374

bool FileExists(const char *filename)

   375

{

   376

	return access(filename, 0) == 0;

   377

}

   378

   379

static int LanguageCompareFunc(const void *a, const void *b)

   380

{

   381

	return strcmp(*(const char* const *)a, *(const char* const *)b);

   382

}

   383

   384

int GetLanguageList(char **languages, int max)

   385

{

   386

	DIR *dir;

   387

	struct dirent *dirent;

   388

	int num = 0;

   389

   390

	dir = opendir(_path.lang_dir);

   391

	if (dir != NULL) {

   392

		while ((dirent = readdir(dir))) {

   393

			char *t = strrchr(dirent->d_name, '.');

   394

			if (t && !strcmp(t, ".lng")) {

   395

				languages[num++] = strdup(dirent->d_name);

   396

				if (num == max) break;

   397

			}

   398

		}

   399

		closedir(dir);

   400

	}

   401

   402

	qsort(languages, num, sizeof(char*), LanguageCompareFunc);

   403

	return num;

   404

}

   405

   406

static void ChangeWorkingDirectory(char *exe)

   407

{

   408

	char *s = strrchr(exe, '/');

   409

	if (s != NULL) {

   410

		*s = 0;

   411

		chdir(exe);

   412

		*s = '/';

   413

	}

   414

}

   415

   416

void ShowInfo(const char *str)

   417

{

   418

	puts(str);

   419

}

   420

   421

void ShowOSErrorBox(const char *buf)

   422

{

   423

#if defined(__APPLE__)

   424

	// this creates an error in the console and then opens the console.

   425

	// Colourcodes are not used in the console, so they are skipped here

   426

	fprintf(stderr, "Error: %s", buf);

   427

	system("/Applications/Utilities/Console.app/Contents/MacOS/Console &");

   428

#else

   429

	// all systems, but OSX

   430

	fprintf(stderr, "\033[1;31mError: %s\033[0;39m\n", buf);

   431

#endif

   432

}

   433

   434

int CDECL main(int argc, char* argv[])

   435

{

   436

	// change the working directory to enable doubleclicking in UIs

   437

#if defined(__BEOS__)

   438

	ChangeWorkingDirectory(argv[0]);

   439

#endif

   440

#if defined(__linux__)

   441

	ChangeWorkingDirectory(argv[0]);

   442

#endif

   443

   444

	_random_seeds[0][1] = _random_seeds[0][0] = time(NULL);

   445

   446

   447

	return ttd_main(argc, argv);

   448

}

   449

   450

void DeterminePaths()

   451

{

   452

	char *s;

   453

   454

	_path.game_data_dir = malloc( MAX_PATH );

   455

	ttd_strlcpy(_path.game_data_dir, GAME_DATA_DIR, MAX_PATH);

   456

	#if defined SECOND_DATA_DIR

   457

	_path.second_data_dir = malloc( MAX_PATH );

   458

	ttd_strlcpy( _path.second_data_dir, SECOND_DATA_DIR, MAX_PATH);

   459

	#endif

   460

   461

#if defined(USE_HOMEDIR)

   462

	{

   463

		char *homedir;

   464

		homedir = getenv("HOME");

   465

   466

		if(!homedir) {

   467

			struct passwd *pw = getpwuid(getuid());

   468

			if (pw) homedir = pw->pw_dir;

   469

		}

   470

   471

		_path.personal_dir = str_fmt("%s" PATHSEP "%s", homedir, PERSONAL_DIR);

   472

	}

   473

   474

#else /* not defined(USE_HOMEDIR) */

   475

   476

	_path.personal_dir = malloc( MAX_PATH );

   477

	ttd_strlcpy(_path.personal_dir, PERSONAL_DIR, MAX_PATH);

   478

   479

	// check if absolute or relative path

   480

	s = strchr(_path.personal_dir, '/');

   481

   482

	// add absolute path

   483

	if (s==NULL || _path.personal_dir != s) {

   484

		getcwd(_path.personal_dir, MAX_PATH);

   485

		s = strchr(_path.personal_dir, 0);

   486

		*s++ = '/';

   487

		ttd_strlcpy(s, PERSONAL_DIR, MAX_PATH);

   488

	}

   489

   490

#endif /* defined(USE_HOMEDIR) */

   491

   492

	s = strchr(_path.personal_dir, 0);

   493

   494

	// append a / ?

   495

	if (s[-1] != '/') { s[0] = '/'; s[1] = 0; }

   496

   497

	_path.save_dir = str_fmt("%ssave", _path.personal_dir);

   498

	_path.autosave_dir = str_fmt("%s/autosave", _path.save_dir);

   499

	_path.scenario_dir = str_fmt("%sscenario", _path.personal_dir);

   500

	_path.gm_dir = str_fmt("%sgm/", _path.game_data_dir);

   501

	_path.data_dir = str_fmt("%sdata/", _path.game_data_dir);

   502

	_config_file = str_fmt("%sopenttd.cfg", _path.personal_dir);

   503

   504

#if defined CUSTOM_LANG_DIR

   505

	// sets the search path for lng files to the custom one

   506

	_path.lang_dir = malloc( MAX_PATH );

   507

	ttd_strlcpy( _path.lang_dir, CUSTOM_LANG_DIR, MAX_PATH);

   508

#else

   509

	_path.lang_dir = str_fmt("%slang/", _path.game_data_dir);

   510

#endif

   511

   512

	// create necessary folders

   513

	mkdir(_path.personal_dir, 0755);

   514

	mkdir(_path.save_dir, 0755);

   515

	mkdir(_path.autosave_dir, 0755);

   516

	mkdir(_path.scenario_dir, 0755);

   517

}