1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "string.h"

     4

#include "table/strings.h"

     5

#include "hal.h"

     6

     7

#include <direct.h>

     8

#include <unistd.h>

     9

#include <sys/stat.h>

    10

#include <stdarg.h>

    11

#include <time.h>

    12

#include <dos.h>

    13

    14

#define INCL_DOS

    15

#define INCL_OS2MM

    16

#define INCL_WIN

    17

    18

#include <os2.h>

    19

#include <os2me.h>

    20

    21

#if defined(WITH_SDL)

    22

#include <SDL.h>

    23

#endif

    24

    25

static char *_fios_path;

    26

static char *_fios_save_path;

    27

static char *_fios_scn_path;

    28

static FiosItem *_fios_items;

    29

static int _fios_count, _fios_alloc;

    30

    31

static FiosItem *FiosAlloc()

    32

{

    33

	if (_fios_count == _fios_alloc) {

    34

		_fios_alloc += 256;

    35

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

    36

	}

    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 = stricmp(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

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

    57

{

    58

	char paths[MAX_PATH];

    59

    60

	append_path(paths, path, file);

    61

	return opendir(paths);

    62

}

    63

    64

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

    65

{

    66

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

    67

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

    68

	else

    69

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

    70

}

    71

    72

// Get a list of savegames

    73

FiosItem *FiosGetSavegameList(int *num, int mode)

    74

{

    75

	FiosItem *fios;

    76

	DIR *dir;

    77

	struct dirent *dirent;

    78

	struct stat sb;

    79

	int sort_start;

    80

	char filename[MAX_PATH];

    81

    82

	if (_fios_save_path == NULL) {

    83

		_fios_save_path = malloc(MAX_PATH);

    84

		strcpy(_fios_save_path, _path.save_dir);

    85

	}

    86

    87

	if (_game_mode == GM_EDITOR)

    88

		_fios_path = _fios_scn_path;

    89

	else

    90

		_fios_path = _fios_save_path;

    91

    92

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

    93

	if (_fios_path[3] != 0) {

    94

		fios = FiosAlloc();

    95

		fios->type = FIOS_TYPE_PARENT;

    96

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

    97

	}

    98

    99

	// Show subdirectories first

   100

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

   101

	if (dir != NULL) {

   102

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

   103

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

   104

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

   105

				if (S_ISDIR(sb.st_mode)) {

   106

					if (!(dirent->d_name[0] == '.' && (dirent->d_name[1] == 0 || (dirent->d_name[1] == '.' && dirent->d_name[2] == 0))))

   107

					{

   108

						fios = FiosAlloc();

   109

						fios->type = FIOS_TYPE_DIR;

   110

						strcpy(fios->name, dirent->d_name);

   111

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

   112

					}

   113

				}

   114

			}

   115

		}

   116

		closedir(dir);

   117

	}

   118

   119

	{

   120

		/* XXX ugly global variables ... */

   121

		byte order = _savegame_sort_order;

   122

		_savegame_sort_order = 2; // sort ascending by name

   123

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

   124

		_savegame_sort_order = order;

   125

	}

   126

   127

	// this is where to start sorting

   128

	sort_start = _fios_count;

   129

   130

	/*      Show savegame files

   131

	 *      .SAV    OpenTTD saved game

   132

	 *      .SS1    Transport Tycoon Deluxe preset game

   133

	 *      .SV1    Transport Tycoon Deluxe (Patch) saved game

   134

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

   135

	 */

   136

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

   137

	if (dir != NULL) {

   138

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

   139

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

   140

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

   141

				if (!S_ISDIR(sb.st_mode)) {

   142

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

   143

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

   144

						*t = 0; // cut extension

   145

						fios = FiosAlloc();

   146

						fios->type = FIOS_TYPE_FILE;

   147

						fios->mtime = sb.st_mtime;

   148

						fios->title[0] = 0;

   149

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

   150

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

   151

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

   152

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

   153

							*t = 0; // cut extension

   154

							fios = FiosAlloc();

   155

							fios->old_extension = ext-1;

   156

							fios->type = FIOS_TYPE_OLDFILE;

   157

							fios->mtime = sb.st_mtime;

   158

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

   159

							GetOldSaveGameName(fios->title, filename);

   160

						}

   161

					}

   162

				}

   163

			}

   164

		}

   165

		closedir(dir);

   166

	}

   167

   168

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

   169

   170

	// Drives

   171

	{

   172

		unsigned save, disk, disk2, total;

   173

   174

		/* save original drive */

   175

		_dos_getdrive(&save);

   176

   177

		/* get available drive letters */

   178

   179

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

   180

		{

   181

			_dos_setdrive(disk, &total);

   182

			_dos_getdrive(&disk2);

   183

   184

			if (disk == disk2)

   185

			{

   186

				fios = FiosAlloc();

   187

				fios->type = FIOS_TYPE_DRIVE;

   188

				fios->title[0] = disk + 'A'-1;

   189

				fios->title[1] = ':';

   190

				fios->title[2] = 0;

   191

			}

   192

		}

   193

   194

		_dos_setdrive(save, &total);

   195

	}

   196

   197

	*num = _fios_count;

   198

	return _fios_items;

   199

}

   200

   201

// Get a list of scenarios

   202

FiosItem *FiosGetScenarioList(int *num, int mode)

   203

{

   204

	FiosItem *fios;

   205

	DIR *dir;

   206

	struct dirent *dirent;

   207

	struct stat sb;

   208

	int sort_start;

   209

	char filename[MAX_PATH];

   210

   211

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

   212

		if (_fios_scn_path == NULL)

   213

			_fios_scn_path = malloc(MAX_PATH);

   214

		strcpy(_fios_scn_path, _path.scenario_dir);

   215

	}

   216

   217

	_fios_path = _fios_scn_path;

   218

   219

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

   220

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

   221

		fios = FiosAlloc();

   222

		fios->type = FIOS_TYPE_PARENT;

   223

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

   224

	}

   225

   226

	// Show subdirectories first

   227

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

   228

	if (dir != NULL) {

   229

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

   230

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

   231

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

   232

				if (S_ISDIR(sb.st_mode)) {

   233

					if (!(dirent->d_name[0] == '.' && (dirent->d_name[1] == 0 || (dirent->d_name[1] == '.' && dirent->d_name[2] == 0))))

   234

					{

   235

						fios = FiosAlloc();

   236

						fios->mtime = 0;

   237

						fios->type = FIOS_TYPE_DIR;

   238

						strcpy(fios->name, dirent->d_name);

   239

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

   240

					}

   241

				}

   242

			}

   243

		}

   244

		closedir(dir);

   245

	}

   246

   247

	// this is where to start sorting

   248

	sort_start = _fios_count;

   249

   250

	/*      Show scenario files

   251

	 *      .SCN    OpenTTD style scenario file

   252

	 *      .SV0    Transport Tycoon Deluxe (Patch) scenario

   253

	 *      .SS0    Transport Tycoon Deluxe preset scenario

   254

	 */

   255

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

   256

	if (dir != NULL) {

   257

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

   258

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

   259

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

   260

				if (!S_ISDIR(sb.st_mode)) {

   261

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

   262

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

   263

						*t = 0; // cut extension

   264

						fios = FiosAlloc();

   265

						fios->type = FIOS_TYPE_SCENARIO;

   266

						fios->mtime = sb.st_mtime;

   267

						fios->title[0] = 0;

   268

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

   269

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

   270

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

   271

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

   272

							*t = 0; // cut extension

   273

							fios = FiosAlloc();

   274

							fios->old_extension = ext-1;

   275

							fios->type = FIOS_TYPE_OLD_SCENARIO;

   276

							fios->mtime = sb.st_mtime;

   277

							GetOldScenarioGameName(fios->title, filename);

   278

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

   279

						}

   280

					}

   281

				}

   282

			}

   283

		}

   284

		closedir(dir);

   285

	}

   286

   287

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

   288

   289

	// Drives

   290

	if (mode != SLD_NEW_GAME)

   291

	{

   292

		unsigned save, disk, disk2, total;

   293

   294

		/* save original drive */

   295

		_dos_getdrive(&save);

   296

   297

		/* get available drive letters */

   298

   299

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

   300

		{

   301

			_dos_setdrive(disk, &total);

   302

			_dos_getdrive(&disk2);

   303

   304

			if (disk == disk2)

   305

			{

   306

				fios = FiosAlloc();

   307

				fios->type = FIOS_TYPE_DRIVE;

   308

				fios->title[0] = disk + 'A'-1;

   309

				fios->title[1] = ':';

   310

				fios->title[2] = 0;

   311

			}

   312

		}

   313

   314

		_dos_setdrive(save, &total);

   315

	}

   316

   317

	*num = _fios_count;

   318

	return _fios_items;

   319

}

   320

   321

   322

// Free the list of savegames

   323

void FiosFreeSavegameList()

   324

{

   325

	free(_fios_items);

   326

	_fios_items = NULL;

   327

	_fios_alloc = _fios_count = 0;

   328

}

   329

   330

// Browse to

   331

char *FiosBrowseTo(const FiosItem *item)

   332

{

   334

	char *path = _fios_path;

   335

	char *s;

   336

   337

	switch(item->type) {

   338

	case FIOS_TYPE_DRIVE:

   339

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

   340

		break;

   341

   342

	case FIOS_TYPE_PARENT:

   343

		// Skip drive part

   344

		path += 3;

   345

		s = path;

   346

		while (*path) {

   347

			if (*path== '\\')

   348

				s = path;

   349

			path++;

   350

		}

   351

		*s = 0;

   352

		break;

   353

   354

	case FIOS_TYPE_DIR:

   355

		// Scan to end

   356

		while (*++path);

   357

		// Add backslash?

   358

		if (path[-1] != '\\') *path++ = '\\';

   359

   360

		strcpy(path, item->name);

   361

		break;

   362

   363

	case FIOS_TYPE_FILE:

   364

		FiosMakeSavegameName(str_buffr, item->name);

   365

		return str_buffr;

   366

   367

	case FIOS_TYPE_OLDFILE:

   368

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

   369

		return str_buffr;

   370

   371

	case FIOS_TYPE_SCENARIO:

   372

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

   373

		return str_buffr;

   374

	case FIOS_TYPE_OLD_SCENARIO:

   375

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

   376

		return str_buffr;

   377

	}

   378

   379

	return NULL;

   380

}

   381

   382

// Get descriptive texts.

   383

// Returns a path as well as a

   384

//  string describing the path.

   385

StringID FiosGetDescText(const char **path)

   386

{

   387

	struct diskfree_t free;

   388

	char drive;

   389

   390

	*path = _fios_path;

   391

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

   392

   393

	_getdiskfree(drive, &free);

   394

   395

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

   396

	return STR_4005_BYTES_FREE;

   397

}

   398

   399

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

   400

{

   401

	if(_game_mode==GM_EDITOR)

   402

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

   403

	else

   404

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

   405

}

   406

   407

void FiosDelete(const char *name)

   408

{

   409

	char path[512];

   410

   411

	FiosMakeSavegameName(path, name);

   412

	unlink(path);

   413

}

   414

   415

const DriverDesc _video_driver_descs[] = {

   416

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

   417

#if defined(WITH_SDL)

   418

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

   419

#endif

   420

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

   421

	{	NULL,			NULL,						NULL,						0}

   422

};

   423

   424

const DriverDesc _sound_driver_descs[] = {

   425

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

   426

#if defined(WITH_SDL)

   427

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

   428

#endif

   429

	{	NULL,	NULL,					NULL,						0}

   430

};

   431

   432

const DriverDesc _music_driver_descs[] = {

   433

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

   434

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

   435

	{	NULL,		NULL,						NULL,						0}

   436

};

   437

   438

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

   439

	 Not needed for OS/2. */

   440

byte GetOSVersion()

   441

{

   442

	return 2;  // any arbitrary number bigger then 0

   443

}

   444

   445

bool FileExists(const char *filename)

   446

{

   447

	return access(filename, 0) == 0;

   448

}

   449

   450

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

   451

{

   452

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

   453

}

   454

   455

int GetLanguageList(char **languages, int max)

   456

{

   457

	DIR *dir;

   458

	struct dirent *dirent;

   459

	int num = 0;

   460

   461

	dir = opendir(_path.lang_dir);

   462

	if (dir != NULL) {

   463

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

   464

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

   465

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

   466

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

   467

				if (num == max) break;

   468

			}

   469

		}

   470

		closedir(dir);

   471

	}

   472

   473

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

   474

	return num;

   475

}

   476

   477

static void ChangeWorkingDirectory(char *exe)

   478

{

   479

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

   480

	if (s != NULL) {

   481

		*s = 0;

   482

		chdir(exe);

   483

		*s = '\\';

   484

	}

   485

}

   486

   487

void ShowInfo(const char *str)

   488

{

   489

	HAB hab;

   490

	HMQ hmq;

   491

	ULONG rc;