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;

   202

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

   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;

   320

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

   321

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

   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

/**

   379

 * Get descriptive texts. Returns the path and free space

   380

 * left on the device

   381

 * @param path string describing the path

   382

 * @param tfs total free space in megabytes, optional (can be NULL)

   383

 * @return StringID describing the path (free space or failure)

   384

 */

   385

StringID FiosGetDescText(const char **path, uint32 *tot)

   386

{

   387

	struct diskfree_t free;

   388

	char drive;

   389

   390

	*path = _fios_path;

   391

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

   392

   393

	if (tot != NULL && _getdiskfree(drive, &free) == 0) {

   394

		*tot = free.avail_clusters * free.sectors_per_cluster * free.bytes_per_sector;

   395

		return STR_4005_BYTES_FREE;

   396

	}

   397

   398

	return STR_4006_UNABLE_TO_READ_DRIVE;

   399

}

   400

   401

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

   402

{

   403

	const char* extension;

   404

	const char* period;

   405

   406

	if (_game_mode == GM_EDITOR)

   407

		extension = ".scn";

   408

	else

   409

		extension = ".sav";

   410

   411

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

   412

	period = strrchr(name, '.');

   413

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

   414

   415

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

   416

}

   417

   418

void FiosDelete(const char *name)

   419

{

   420

	char path[512];

   421

   422

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

   423

	unlink(path);

   424

}

   425

   426

const DriverDesc _video_driver_descs[] = {

   427

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

   428

#if defined(WITH_SDL)

   429

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

   430

#endif

   431

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

   432

	{	NULL,			NULL,						NULL,						0}

   433

};

   434

   435

const DriverDesc _sound_driver_descs[] = {

   436

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

   437

#if defined(WITH_SDL)

   438

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

   439

#endif

   440

	{	NULL,	NULL,					NULL,						0}

   441

};

   442

   443

const DriverDesc _music_driver_descs[] = {

   444

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

   445

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

   446

	{	NULL,		NULL,						NULL,						0}

   447

};

   448

   449

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

   450

	 Not needed for OS/2. */

   451

byte GetOSVersion(void)

   452

{

   453

	return 2;  // any arbitrary number bigger then 0

   454

}

   455

   456

bool FileExists(const char *filename)

   457

{

   458

	return access(filename, 0) == 0;

   459

}

   460

   461

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

   462

{

   463

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

   464

}

   465

   466

int GetLanguageList(char **languages, int max)

   467

{

   468

	DIR *dir;

   469

	struct dirent *dirent;

   470

	int num = 0;

   471

   472

	dir = opendir(_path.lang_dir);

   473

	if (dir != NULL) {

   474

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

   475

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

   476

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

   477

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

   478

				if (num == max) break;

   479

			}

   480

		}

   481

		closedir(dir);

   482

	}

   483

   484

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

   485

	return num;

   486

}

   487