1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "window.h"

     4

#include "string.h"

     5

#include "table/strings.h"

     6

#include "hal.h"

     7

     8

#include <direct.h>

     9

#include <unistd.h>

    10

#include <sys/stat.h>

    11

#include <stdarg.h>

    12

#include <time.h>

    13

#include <dos.h>

    14

    15

#define INCL_DOS

    16

#define INCL_OS2MM

    17

#define INCL_WIN

    18

#define INCL_WINCLIPBOARD

    19

    20

#include <os2.h>

    21

#include <os2me.h>

    22

    23

#if defined(WITH_SDL)

    24

#include <SDL.h>

    25

#endif

    26

    27

static inline int strcasecmp(const char* s1, const char* s2)

    28

{

    29

	return stricmp(s1, s2);

    30

}

    31

    32

static char *_fios_path;

    33

static char *_fios_save_path;

    34

static char *_fios_scn_path;

    35

static FiosItem *_fios_items;

    36

static int _fios_count, _fios_alloc;

    37

    38

static FiosItem *FiosAlloc(void)

    39

{

    40

	if (_fios_count == _fios_alloc) {

    41

		_fios_alloc += 256;

    42

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

    43

	}

    44

	return &_fios_items[_fios_count++];

    45

}

    46

    47

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

    48

{

    49

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

    50

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

    51

	int r;

    52

    53

	if (_savegame_sort_order < 2) // sort by date

    54

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

    55

	else

    56

		r = strcasecmp(

    57

			da->title[0] != '\0' ? da->title : da->name,

    58

			db->title[0] != '\0' ? db->title : db->name

    59

		);

    60

    61

	if (_savegame_sort_order & 1) r = -r;

    62

	return r;

    63

}

    64

    65

    66

static DIR *my_opendir(char *path, char *file)

    67

{

    68

	char paths[MAX_PATH];

    69

    70

	append_path(paths, path, file);

    71

	return opendir(paths);

    72

}

    73

    74

static void append_path(char *out, const char *path, const char *file)

    75

{

    76

	if (path[2] == '\\' && path[3] == '\0')

    77

		sprintf(out, "%s%s", path, file);

    78

	else

    79

		sprintf(out, "%s\\%s", path, file);

    80

}

    81

    82

// Get a list of savegames

    83

FiosItem *FiosGetSavegameList(int *num, int mode)

    84

{

    85

	FiosItem *fios;

    86

	DIR *dir;

    87

	struct dirent *dirent;

    88

	struct stat sb;

    89

	int sort_start;

    90

	char filename[MAX_PATH];

    91

    92

	if (_fios_save_path == NULL) {

    93

		_fios_save_path = malloc(MAX_PATH);

    94

		strcpy(_fios_save_path, _path.save_dir);

    95

	}

    96

    97

	if (_game_mode == GM_EDITOR)

    98

		_fios_path = _fios_scn_path;

    99

	else

   100

		_fios_path = _fios_save_path;

   101

   102

	// Parent directory, only if not of the type C:\.

   103

	if (_fios_path[3] != '\0') {

   104

		fios = FiosAlloc();

   105

		fios->type = FIOS_TYPE_PARENT;

   106

		fios->mtime = 0;

   107

		strcpy(fios->name, "..");

   108

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

   109

	}

   110

   111

	// Show subdirectories first

   112

	dir = my_opendir(_fios_path, "*.*");

   113

	if (dir != NULL) {

   114

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

   115

			append_path(filename, _fios_path, dirent->d_name);

   116

			if (!stat(filename, &sb) && S_ISDIR(sb.st_mode) &&

   117

					strcmp(filename, ".") != 0 &&

   118

					strcmp(filename, "..") != 0) {

   119

				fios = FiosAlloc();

   120

				fios->type = FIOS_TYPE_DIR;

   121

				fios->mtime = 0;

   122

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

   123

				snprintf(fios->title, lengthof(fios->title),

   124

					"%s\\ (Directory)", dirent->d_name);

   125

			}

   126

		}

   127

		closedir(dir);

   128

	}

   129

   130

	{

   131

		/* XXX ugly global variables ... */

   132

		byte order = _savegame_sort_order;

   133

		_savegame_sort_order = 2; // sort ascending by name

   134

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

   135

		_savegame_sort_order = order;

   136

	}

   137

   138

	// this is where to start sorting

   139

	sort_start = _fios_count;

   140

   141

	/* Show savegame files

   142

	 * .SAV OpenTTD saved game

   143

	 * .SS1 Transport Tycoon Deluxe preset game

   144

	 * .SV1 Transport Tycoon Deluxe (Patch) saved game

   145

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

   146

	 */

   147

	dir = my_opendir(_fios_path, "*.*");

   148

	if (dir != NULL) {

   149

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

   150

			char *t;

   151

   152

			append_path(filename, _fios_path, dirent->d_name);

   153

			if (stat(filename, &sb) || S_ISDIR(sb.st_mode)) continue;

   154

   155

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

   156

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

   157

				fios = FiosAlloc();

   158

				fios->type = FIOS_TYPE_FILE;

   159

				fios->mtime = sb.st_mtime;

   160

				fios->title[0] = '\0';

   161

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

   162

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

   163

				if (t != NULL && (

   164

							strcasecmp(t, ".ss1") == 0 ||

   165

							strcasecmp(t, ".sv1") == 0 ||

   166

							strcasecmp(t, ".sv2") == 0

   167

						)) { // TTDLX(Patch)

   168

					fios = FiosAlloc();

   169

					fios->type = FIOS_TYPE_OLDFILE;

   170

					fios->mtime = sb.st_mtime;

   171

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

   172

					GetOldSaveGameName(fios->title, filename);

   173

				}

   174

			}

   175

		}

   176

		closedir(dir);

   177

	}

   178

   179

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

   180

   181

	// Drives

   182

	{

   183

		uint save;

   184

		uint disk;

   185

		uint total;

   186

   187

		/* save original drive */

   188

		_dos_getdrive(&save);

   189

   190

		/* get available drive letters */

   191

		for (disk = 1; disk < 27; ++disk)

   192

		{

   193

			uint disk2;

   194

   195

			_dos_setdrive(disk, &total);

   196

			_dos_getdrive(&disk2);

   197

   198

			if (disk == disk2)

   199

			{

   200

				fios = FiosAlloc();

   201

				fios->type = FIOS_TYPE_DRIVE;

   203

				sprintf(fios->title, "%c:", 'A' + disk - 1);

   204

			}

   205

		}

   206

   207

		_dos_setdrive(save, &total);

   208

	}

   209

   210

	*num = _fios_count;

   211

	return _fios_items;

   212

}

   213

   214

// Get a list of scenarios

   215

FiosItem *FiosGetScenarioList(int *num, int mode)

   216

{

   217

	FiosItem *fios;

   218

	DIR *dir;

   219

	struct dirent *dirent;

   220

	struct stat sb;

   221

	int sort_start;

   222

	char filename[MAX_PATH];

   223

   224

	if (mode == SLD_NEW_GAME || _fios_scn_path == NULL) {

   225

		if (_fios_scn_path == NULL)

   226

			_fios_scn_path = malloc(MAX_PATH);

   227

		strcpy(_fios_scn_path, _path.scenario_dir);

   228

	}

   229

   230

	_fios_path = _fios_scn_path;

   231

   232

	// Parent directory, only if not of the type C:\.

   233

	if (_fios_path[3] != '\0' && mode != SLD_NEW_GAME) {

   234

		fios = FiosAlloc();

   235

		fios->type = FIOS_TYPE_PARENT;

   236

		fios->mtime = 0;

   237

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

   238

	}

   239

   240

	// Show subdirectories first

   241

	dir = my_opendir(_fios_path, "*.*");

   242

	if (dir != NULL) {

   243

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

   244

			append_path(filename, _fios_path, dirent->d_name);

   245

			if (!stat(filename, &sb) && S_ISDIR(sb.st_mode) &&

   246

					strcmp(filename, ".") != 0 &&

   247

					strcmp(filename, "..") != 0) {

   248

				fios = FiosAlloc();

   249

				fios->type = FIOS_TYPE_DIR;

   250

				fios->mtime = 0;

   251

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

   252

				snprintf(fios->title, lengthof(fios->title),

   253

					"%s\\ (Directory)", dirent->d_name);

   254

			}

   255

		}

   256

		closedir(dir);

   257

	}

   258

   259

	// this is where to start sorting

   260

	sort_start = _fios_count;

   261

   262

	/* Show scenario files

   263

	 * .SCN OpenTTD style scenario file

   264

	 * .SV0 Transport Tycoon Deluxe (Patch) scenario

   265

	 * .SS0 Transport Tycoon Deluxe preset scenario

   266

	 */

   267

	dir = my_opendir(_fios_path, "*.*");

   268

	if (dir != NULL) {

   269

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

   270

			char *t;

   271

   272

			append_path(filename, _fios_path, dirent->d_name);

   273

			if (stat(filename, &sb) || S_ISDIR(sb.st_mode)) continue;

   274

   275

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

   276

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

   277

				fios = FiosAlloc();

   278

				fios->type = FIOS_TYPE_SCENARIO;

   279

				fios->mtime = sb.st_mtime;

   280

				fios->title[0] = '\0';

   281

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

   282

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

   283

					mode == SLD_NEW_GAME) {

   284

				if (t != NULL && (

   285

							strcasecmp(t, ".sv0") == 0 ||

   286

							strcasecmp(t, ".ss0") == 0

   287

						)) { // TTDLX(Patch)

   288

					fios = FiosAlloc();

   289

					fios->type = FIOS_TYPE_OLD_SCENARIO;

   290

					fios->mtime = sb.st_mtime;

   291

					GetOldScenarioGameName(fios->title, filename);

   292

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

   293

				}

   294

			}

   295

		}

   296

		closedir(dir);

   297

	}

   298

   299

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

   300

   301

	// Drives

   302

	if (mode != SLD_NEW_GAME)

   303

	{

   304

		unsigned save, disk, disk2, total;

   305

   306

		/* save original drive */

   307

		_dos_getdrive(&save);

   308

   309

		/* get available drive letters */

   310

   311

		for (disk = 1; disk < 27; ++disk)

   312

		{

   313

			_dos_setdrive(disk, &total);

   314

			_dos_getdrive(&disk2);

   315

   316

			if (disk == disk2)

   317

			{

   318

				fios = FiosAlloc();

   319

				fios->type = FIOS_TYPE_DRIVE;

   322

			}

   323

		}

   324

   325

		_dos_setdrive(save, &total);

   326

	}

   327

   328

	*num = _fios_count;

   329

	return _fios_items;

   330

}

   331

   332

   333

// Free the list of savegames

   334

void FiosFreeSavegameList(void)

   335

{

   336

	free(_fios_items);

   337

	_fios_items = NULL;

   338

	_fios_alloc = _fios_count = 0;

   339

}

   340

   341

// Browse to

   342

char *FiosBrowseTo(const FiosItem *item)

   343

{

   344

	char *path = _fios_path;

   345

	char *s;

   346

   347

	switch (item->type) {

   348

		case FIOS_TYPE_DRIVE:

   349

			sprintf(path, "%c:\\", item->title[0]);

   350

			break;

   351

   352

		case FIOS_TYPE_PARENT:

   353

			s = strrchr(path, '\\');

   354

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

   355

			break;

   356

   357

		case FIOS_TYPE_DIR:

   358

			s = strchr(item->name, '\\');

   359

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

   360

			strcat(path, "\\");

   361

			strcat(path, item->name);

   362

			break;

   363

   364

		case FIOS_TYPE_FILE:

   365

		case FIOS_TYPE_OLDFILE:

   366

		case FIOS_TYPE_SCENARIO:

   367

		case FIOS_TYPE_OLD_SCENARIO: {

   368

			static char str_buffr[512];

   369

   370

			sprintf(str_buffr, "%s\\%s", path, item->name);

   371

			return str_buffr;

   372

		}

   373

	}

   374

   375

	return NULL;

   376

}

   377

   378

// Get descriptive texts.

   379

// Returns a path as well as a

   380

//  string describing the path.

   381

StringID FiosGetDescText(const char **path)

   382

{

   383

	struct diskfree_t free;

   384

	char drive;

   385

   386

	*path = _fios_path;

   387

	drive = *path[0] - 'A' + 1;

   388

   389

	_getdiskfree(drive, &free);

   390

   391

	SetDParam(0, free.avail_clusters * free.sectors_per_cluster * free.bytes_per_sector);

   392

	return STR_4005_BYTES_FREE;

   393

}

   394

   395

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

   396

{

   397

	const char* extension;

   398

	const char* period;

   399

   400

	if (_game_mode == GM_EDITOR)

   401

		extension = ".scn";

   402

	else

   403

		extension = ".sav";

   404

   405

	// Don't append the extension, if it is already there

   406

	period = strrchr(name, '.');

   407

	if (period != NULL && strcasecmp(period, extension) == 0) extension = "";

   408

   409

	sprintf(buf, "%s\\%s%s", _fios_path, name, extension);

   410

}

   411

   412

void FiosDelete(const char *name)

   413

{

   414

	char path[512];

   415

   416

	snprintf(path, lengthof(path), "%s\\%s", _fios_path, name);

   417

	unlink(path);

   418

}

   419

   420

const DriverDesc _video_driver_descs[] = {

   421

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

   422

#if defined(WITH_SDL)

   423

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

   424

#endif

   425

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

   426

	{	NULL,			NULL,						NULL,						0}

   427

};

   428

   429

const DriverDesc _sound_driver_descs[] = {

   430

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

   431

#if defined(WITH_SDL)

   432

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

   433

#endif

   434

	{	NULL,	NULL,					NULL,						0}

   435

};

   436

   437

const DriverDesc _music_driver_descs[] = {

   438

	{	"os2",		"OS/2 Music Driver",		&_os2_music_driver,			0},

   439

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

   440

	{	NULL,		NULL,						NULL,						0}

   441

};

   442

   443

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

   444

	 Not needed for OS/2. */

   445

byte GetOSVersion(void)

   446

{

   447

	return 2;  // any arbitrary number bigger then 0

   448

}

   449

   450

bool FileExists(const char *filename)

   451

{

   452

	return access(filename, 0) == 0;

   453

}

   454

   455

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

   456

{

   457

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

   458

}

   459

   460

int GetLanguageList(char **languages, int max)

   461

{

   462

	DIR *dir;

   463

	struct dirent *dirent;

   464

	int num = 0;

   465

   466

	dir = opendir(_path.lang_dir);

   467

	if (dir != NULL) {

   468

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

   469

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

   470

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

   471

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

   472

				if (num == max) break;

   473

			}

   474

		}

   475

		closedir(dir);

   476

	}

   477

   478

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

   479

	return num;

   480

}

   481

   482

static void ChangeWorkingDirectory(char *exe)

   483

{

   484

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

   485

	if (s != NULL) {

   486

		*s = '\0';

   487

		chdir(exe);

   488

		*s = '\\';