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

		SET_DPARAM32(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

	SET_DPARAM32(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

	{ NULL,		NULL,									NULL,									0}

   335

};

   336

   337

const DriverDesc _sound_driver_descs[] = {

   338

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

   339

#if defined(WITH_SDL)

   340

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

   341

#endif

   342

	{ NULL,		NULL,									NULL,										0}

   343

};

   344

   345

#if defined(__APPLE__)

   346

#define EXTMIDI_PRI 2

   347

#else

   348

#define EXTMIDI_PRI 0

   349

#endif

   350

   351

const DriverDesc _music_driver_descs[] = {

   352

#ifndef __BEOS__

   353

#ifndef __MORPHOS__

   354

// MorphOS have no music support

   355

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

   356

#endif

   357

#endif

   358

#ifdef __BEOS__

   359

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

   360

#endif

   361

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

   362

	{     NULL,	NULL,										NULL,										0}

   363

};

   364

   365

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

   366

	 Not needed for *nix. */

   367

byte GetOSVersion()

   368

{

   369

	return 2;  // any arbitrary number bigger then 0

   370

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

   371

}

   372

   373

bool FileExists(const char *filename)

   374

{

   375

	return access(filename, 0) == 0;

   376

}

   377

   378

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

   379

{

   380

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

   381

}

   382

   383

int GetLanguageList(char **languages, int max)

   384

{

   385

	DIR *dir;

   386

	struct dirent *dirent;

   387

	int num = 0;

   388

   389

	dir = opendir(_path.lang_dir);

   390

	if (dir != NULL) {

   391

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

   392

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

   393

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

   394

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

   395

				if (num == max) break;

   396

			}

   397

		}

   398

		closedir(dir);

   399

	}

   400

   401

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

   402

	return num;

   403

}

   404

   405

static void ChangeWorkingDirectory(char *exe)

   406

{

   407

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

   408

	if (s != NULL) {

   409

		*s = 0;

   410

		chdir(exe);

   411

		*s = '/';

   412

	}

   413

}

   414

   415

void ShowInfo(const char *str)

   416

{

   417

	puts(str);

   418

}

   419

   420

void ShowOSErrorBox(const char *buf)

   421

{

   429

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

   430

#endif

   431

}

   432

   433

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

   434

{

   435

	// change the working directory to enable doubleclicking in UIs

   436

#if defined(__BEOS__)

   437

	ChangeWorkingDirectory(argv[0]);

   438

#endif

   439

#if defined(__linux__)

   440

	ChangeWorkingDirectory(argv[0]);

   441

#endif

   442

   443

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

   444

   445

   446

	return ttd_main(argc, argv);

   447

}

   448

   449

void DeterminePaths()

   450

{

   451

	char *s;

   452

   453

	_path.game_data_dir = malloc( MAX_PATH );

   454

	strcpy(_path.game_data_dir, GAME_DATA_DIR);

   455

   456

#if defined(USE_HOMEDIR)

   457

	{

   458

		char *homedir;

   459

		homedir = getenv("HOME");

   460

   461

		if(!homedir) {

   462

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

   463

			if (pw) homedir = pw->pw_dir;

   464

		}

   465

   466

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

   467

	}

   468

   469

#else /* not defined(USE_HOMEDIR) */

   470

   471

	_path.personal_dir = malloc( MAX_PATH );

   472

	strcpy(_path.personal_dir, PERSONAL_DIR);

   473

   474

	// check if absolute or relative path

   475

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

   476

   477

	// add absolute path

   478

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

   479

		getcwd(_path.personal_dir, MAX_PATH);

   480

		s = strchr(_path.personal_dir, 0);

   481

		*s++ = '/';

   482

		strcpy(s, PERSONAL_DIR);

   483

	}

   484

   485

#endif /* defined(USE_HOMEDIR) */

   486

   487

	s = strchr(_path.personal_dir, 0);

   488

   489

	// append a / ?

   490

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

   491

   492

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

   493

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

   494

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

   495

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

   496

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

   497

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

   498

   499

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

   500

   501

	// create necessary folders

   502

	mkdir(_path.personal_dir, 0755);

   503

	mkdir(_path.save_dir, 0755);

   504

	mkdir(_path.autosave_dir, 0755);

   505

	mkdir(_path.scenario_dir, 0755);

   506

}

   507