1

#include "stdafx.h"

     2

#include "ttd.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

    19

#include <os2.h>

    20

#include <os2me.h>

    21

    22

#if defined(WITH_SDL)

    23

#include <SDL.h>

    24

#endif

    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

    39

	return &_fios_items[_fios_count++];

    40

}

    41

    42

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

    43

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

    44

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

    45

	int r;

    46

    47

	if (_savegame_sort_order < 2) // sort by date

    48

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

    49

	else

    50

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

    51

    52

	if (_savegame_sort_order & 1) r = -r;

    53

	return r;

    54

}

    55

    56

    57

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

    58

{

    59

	char paths[MAX_PATH];

    60

    61

	append_path(paths, path, file);

    62

	return opendir(paths);

    63

}

    64

    65

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

    66

{

    67

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

    68

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

    69

	else

    70

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

    71

}

    72

    73

// Get a list of savegames

    74

FiosItem *FiosGetSavegameList(int *num, int mode)

    75

{

    76

	FiosItem *fios;

    77

	DIR *dir;

    78

	struct dirent *dirent;

    79

	struct stat sb;

    80

	int sort_start;

    81

	char filename[MAX_PATH];

    82

    83

	if (_fios_save_path == NULL) {

    84

		_fios_save_path = malloc(MAX_PATH);

    85

		strcpy(_fios_save_path, _path.save_dir);

    86

	}

    87

    88

	if (_game_mode == GM_EDITOR)

    89

		_fios_path = _fios_scn_path;

    90

	else

    91

		_fios_path = _fios_save_path;

    92

    93

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

    94

	if (_fios_path[3] != 0) {

    95

		fios = FiosAlloc();

    96

		fios->type = FIOS_TYPE_PARENT;

    97

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

    98

	}

    99

   100

	// Show subdirectories first

   101

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

   102

	if (dir != NULL) {

   103

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

   104

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

   105

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

   106

				if (S_ISDIR(sb.st_mode)) {

   107

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

   108

					{

   109

						fios = FiosAlloc();

   110

						fios->type = FIOS_TYPE_DIR;

   111

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

   112

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

   113

					}

   114

				}

   115

			}

   116

		}

   117

		closedir(dir);

   118

	}

   119

   120

	{

   121

		/* XXX ugly global variables ... */

   122

		byte order = _savegame_sort_order;

   123

		_savegame_sort_order = 2; // sort ascending by name

   124

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

   125

		_savegame_sort_order = order;

   126

	}

   127

   128

	// this is where to start sorting

   129

	sort_start = _fios_count;

   130

   131

	/*      Show savegame files

   132

	 *      .SAV    OpenTTD saved game

   133

	 *      .SS1    Transport Tycoon Deluxe preset game

   134

	 *      .SV1    Transport Tycoon Deluxe (Patch) saved game

   135

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

   136

	 */

   137

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

   138

	if (dir != NULL) {

   139

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

   140

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

   141

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

   142

				if (!S_ISDIR(sb.st_mode)) {

   143

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

   144

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

   145

						*t = 0; // cut extension

   146

						fios = FiosAlloc();

   147

						fios->type = FIOS_TYPE_FILE;

   148

						fios->mtime = sb.st_mtime;

   149

						fios->title[0] = 0;

   150

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

   151

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

   152

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

   153

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

   154

							*t = 0; // cut extension

   155

							fios = FiosAlloc();

   156

							fios->old_extension = ext-1;

   157

							fios->type = FIOS_TYPE_OLDFILE;

   158

							fios->mtime = sb.st_mtime;

   159

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

   160

							GetOldSaveGameName(fios->title, filename);

   161

						}

   162

					}

   163

				}

   164

			}

   165

		}

   166

		closedir(dir);

   167

	}

   168

   169

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

   170

   171

	// Drives

   172

	{

   173

		unsigned save, disk, disk2, total;

   174

   175

		/* save original drive */

   176

		_dos_getdrive(&save);

   177

   178

		/* get available drive letters */

   179

   180

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

   181

		{

   182

			_dos_setdrive(disk, &total);

   183

			_dos_getdrive(&disk2);

   184

   185

			if (disk == disk2)

   186

			{

   187

				fios = FiosAlloc();

   188

				fios->type = FIOS_TYPE_DRIVE;

   189

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

   190

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

   191

				fios->title[2] = 0;

   192

			}

   193

		}

   194

   195

		_dos_setdrive(save, &total);

   196

	}

   197

   198

	*num = _fios_count;

   199

	return _fios_items;

   200

}

   201

   202

// Get a list of scenarios

   203

FiosItem *FiosGetScenarioList(int *num, int mode)

   204

{

   205

	FiosItem *fios;

   206

	DIR *dir;

   207

	struct dirent *dirent;

   208

	struct stat sb;

   209

	int sort_start;

   210

	char filename[MAX_PATH];

   211

   212

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

   213

		if (_fios_scn_path == NULL)

   214

			_fios_scn_path = malloc(MAX_PATH);

   215

		strcpy(_fios_scn_path, _path.scenario_dir);

   216

	}

   217

   218

	_fios_path = _fios_scn_path;

   219

   220

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

   221

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

   222

		fios = FiosAlloc();

   223

		fios->type = FIOS_TYPE_PARENT;

   224

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

   225

	}

   226

   227

	// Show subdirectories first

   228

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

   229

	if (dir != NULL) {

   230

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

   231

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

   232

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

   233

				if (S_ISDIR(sb.st_mode)) {

   234

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

   235

					{

   236

						fios = FiosAlloc();

   237

						fios->mtime = 0;

   238

						fios->type = FIOS_TYPE_DIR;

   239

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

   240

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

   241

					}

   242

				}

   243

			}

   244

		}

   245

		closedir(dir);

   246

	}

   247

   248

	// this is where to start sorting

   249

	sort_start = _fios_count;

   250

   251

	/*      Show scenario files

   252

	 *      .SCN    OpenTTD style scenario file

   253

	 *      .SV0    Transport Tycoon Deluxe (Patch) scenario

   254

	 *      .SS0    Transport Tycoon Deluxe preset scenario

   255

	 */

   256

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

   257

	if (dir != NULL) {

   258

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

   259

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

   260

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

   261

				if (!S_ISDIR(sb.st_mode)) {

   262

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

   263

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

   264

						*t = 0; // cut extension

   265

						fios = FiosAlloc();

   266

						fios->type = FIOS_TYPE_SCENARIO;

   267

						fios->mtime = sb.st_mtime;

   268

						fios->title[0] = 0;

   269

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

   270

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

   271

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

   272

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

   273

							*t = 0; // cut extension

   274

							fios = FiosAlloc();

   275

							fios->old_extension = ext-1;

   276

							fios->type = FIOS_TYPE_OLD_SCENARIO;

   277

							fios->mtime = sb.st_mtime;

   278

							GetOldScenarioGameName(fios->title, filename);

   279

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

   280

						}

   281

					}

   282

				}

   283

			}

   284

		}

   285

		closedir(dir);

   286

	}

   287

   288

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

   289

   290

	// Drives

   291

	if (mode != SLD_NEW_GAME)

   292

	{

   293

		unsigned save, disk, disk2, total;

   294

   295

		/* save original drive */

   296

		_dos_getdrive(&save);

   297

   298

		/* get available drive letters */

   299

   300

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

   301

		{

   302

			_dos_setdrive(disk, &total);

   303

			_dos_getdrive(&disk2);

   304

   305

			if (disk == disk2)

   306

			{

   307

				fios = FiosAlloc();

   308

				fios->type = FIOS_TYPE_DRIVE;

   309

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

   310

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

   311

				fios->title[2] = 0;

   312

			}

   313

		}

   314

   315

		_dos_setdrive(save, &total);

   316

	}

   317

   318

	*num = _fios_count;

   319

	return _fios_items;

   320

}

   321

   322

   323

// Free the list of savegames

   324

void FiosFreeSavegameList()

   325

{

   326

	free(_fios_items);

   327

	_fios_items = NULL;

   328

	_fios_alloc = _fios_count = 0;

   329

}

   330

   331

// Browse to

   332

char *FiosBrowseTo(const FiosItem *item)

   333

{

   334

	static char str_buffr[512];

   335

	char *path = _fios_path;

   336

	char *s;

   337

   338

	switch(item->type) {

   339

	case FIOS_TYPE_DRIVE:

   340

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

   341

		break;

   342

   343

	case FIOS_TYPE_PARENT:

   344

		// Skip drive part

   345

		path += 3;

   346

		s = path;

   347

		while (*path) {

   348

			if (*path== '\\')

   349

				s = path;

   350

			path++;

   351

		}

   352

		*s = 0;

   353

		break;

   354

   355

	case FIOS_TYPE_DIR:

   356

		// Scan to end

   357

		while (*++path);

   358

		// Add backslash?

   359

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

   360

   361

		strcpy(path, item->name);

   362

		break;

   363

   364

	case FIOS_TYPE_FILE:

   365

		FiosMakeSavegameName(str_buffr, item->name);

   366

		return str_buffr;

   367

   368

	case FIOS_TYPE_OLDFILE:

   369

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

   370

		return str_buffr;

   371

   372

	case FIOS_TYPE_SCENARIO:

   373

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

   374

		return str_buffr;

   375

	case FIOS_TYPE_OLD_SCENARIO:

   376

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

   377

		return str_buffr;

   378

	}

   379

   380

	return NULL;

   381

}

   382

   383

// Get descriptive texts.

   384

// Returns a path as well as a

   385

//  string describing the path.

   386

StringID FiosGetDescText(const char **path)

   387

{

   388

	struct diskfree_t free;

   389

	char drive;

   390

   391

	*path = _fios_path;

   392

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

   393

   394

	_getdiskfree(drive, &free);

   395

   396

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

   397

	return STR_4005_BYTES_FREE;

   398

}

   399

   400

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

   401

{

   402

	if(_game_mode==GM_EDITOR)

   403

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

   404

	else

   405

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

   406

}

   407

   408

void FiosDelete(const char *name)

   409

{

   410

	char path[512];

   411

   412

	FiosMakeSavegameName(path, name);

   413

	unlink(path);

   414

}

   415

   416

const DriverDesc _video_driver_descs[] = {

   417

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

   418

#if defined(WITH_SDL)

   419

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

   420

#endif

   421

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

   422

	{	NULL,			NULL,						NULL,						0}

   423

};

   424

   425

const DriverDesc _sound_driver_descs[] = {

   426

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

   427

#if defined(WITH_SDL)

   428

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

   429

#endif

   430

	{	NULL,	NULL,					NULL,						0}

   431

};

   432

   433

const DriverDesc _music_driver_descs[] = {

   434

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

   435

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

   436

	{	NULL,		NULL,						NULL,						0}

   437

};

   438

   439

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

   440

	 Not needed for OS/2. */

   441

byte GetOSVersion()

   442

{

   443

	return 2;  // any arbitrary number bigger then 0

   444

}

   445

   446

bool FileExists(const char *filename)

   447

{

   448

	return access(filename, 0) == 0;

   449

}

   450

   451

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

   452

{

   453

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

   454

}

   455

   456

int GetLanguageList(char **languages, int max)

   457

{

   458

	DIR *dir;

   459

	struct dirent *dirent;

   460

	int num = 0;

   461

   462

	dir = opendir(_path.lang_dir);

   463

	if (dir != NULL) {

   464

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

   465

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

   466

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

   467

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

   468

				if (num == max) break;

   469

			}

   470

		}

   471

		closedir(dir);

   472

	}

   473

   474

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

   475

	return num;

   476

}

   477

   478

static void ChangeWorkingDirectory(char *exe)

   479

{

   480

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

   481

	if (s != NULL) {

   482

		*s = 0;

   483

		chdir(exe);

   484

		*s = '\\';

   485

	}

   486

}

   487

   488

void ShowInfo(const char *str)

   489

{

   490

	HAB hab;