1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "hal.h"

     5

     6

#include <direct.h>

     7

#include <unistd.h>

     8

#include <sys/stat.h>

     9

#include <stdarg.h>

    10

#include <time.h>

    11

#include <dos.h>

    12

    13

#define INCL_DOS

    14

#define INCL_OS2MM

    16

    17

#include <os2.h>

    18

#include <os2me.h>

    19

    20

#if defined(WITH_SDL)

    21

#include <SDL.h>

    22

#endif

    23

    24

static char *_fios_path;

    25

static char *_fios_save_path;

    26

static char *_fios_scn_path;

    27

static FiosItem *_fios_items;

    28

static int _fios_count, _fios_alloc;

    29

    30

static FiosItem *FiosAlloc()

    31

{

    32

	if (_fios_count == _fios_alloc) {

    33

		_fios_alloc += 256;

    34

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

    35

	}

    36

    37

	return &_fios_items[_fios_count++];

    38

}

    39

    40

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

    41

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

    42

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

    43

	int r;

    44

    45

	if (_savegame_sort_order < 2) // sort by date

    46

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

    47

	else

    48

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

    49

    50

	if (_savegame_sort_order & 1) r = -r;

    51

	return r;

    52

}

    53

    54

    55

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

    56

{

    57

	char paths[MAX_PATH];

    58

    59

	append_path(paths, path, file);		

    60

	return opendir(paths);

    61

}

    62

    63

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

    64

{

    65

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

    66

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

    67

	else

    68

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

    69

}

    70

    71

// Get a list of savegames

    72

FiosItem *FiosGetSavegameList(int *num, int mode)

    73

{

    74

	FiosItem *fios;

    75

	DIR *dir;

    76

	struct dirent *dirent;

    77

	struct stat sb;

    78

	int sort_start;

    79

	char filename[MAX_PATH];

    80

    81

	if (_fios_save_path == NULL) {

    82

		_fios_save_path = malloc(MAX_PATH);

    83

		strcpy(_fios_save_path, _path.save_dir);

    84

	}

    85

    86

	if (_game_mode == GM_EDITOR)

    87

		_fios_path = _fios_scn_path;

    88

	else

    89

		_fios_path = _fios_save_path;

    90

    91

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

    92

	if (_fios_path[3] != 0) {

    93

		fios = FiosAlloc();

    94

		fios->type = FIOS_TYPE_PARENT;

    95

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

    96

	}

    97

    98

	// Show subdirectories first

    99

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

   100

	if (dir != NULL) {

   101

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

   102

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

   103

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

   104

				if (S_ISDIR(sb.st_mode)) {

   105

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

   106

					{

   107

						fios = FiosAlloc();

   108

						fios->type = FIOS_TYPE_DIR;

   109

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

   110

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

   111

					}

   112

				}

   113

			}

   114

		}

   115

		closedir(dir);

   116

	}

   117

   118

	{

   119

		/* XXX ugly global variables ... */

   120

		byte order = _savegame_sort_order;

   121

		_savegame_sort_order = 2; // sort ascending by name

   122

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

   123

		_savegame_sort_order = order;

   124

	}

   125

   126

	// this is where to start sorting

   127

	sort_start = _fios_count;

   128

   129

	/*      Show savegame files

   130

	 *      .SAV    OpenTTD saved game

   131

	 *      .SS1    Transport Tycoon Deluxe preset game

   132

	 *      .SV1    Transport Tycoon Deluxe (Patch) saved game

   133

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

   134

	 */

   135

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

   136

	if (dir != NULL) {

   137

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

   138

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

   139

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

   140

				if (!S_ISDIR(sb.st_mode)) {

   141

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

   142

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

   143

						*t = 0; // cut extension

   144

						fios = FiosAlloc();

   145

						fios->type = FIOS_TYPE_FILE;

   146

						fios->mtime = sb.st_mtime;

   147

						fios->title[0] = 0;

   148

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

   149

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

   150

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

   151

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

   152

							*t = 0; // cut extension

   153

							fios = FiosAlloc();

   154

							fios->old_extension = ext-1;

   155

							fios->type = FIOS_TYPE_OLDFILE;

   156

							fios->mtime = sb.st_mtime;

   157

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

   158

							GetOldSaveGameName(fios->title, filename);

   159

						}

   160

					}

   161

				}

   162

			}

   163

		}

   164

		closedir(dir);

   165

	}

   166

   167

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

   168

   169

	// Drives

   170

	{

   171

		unsigned save, disk, disk2, total;

   172

   173

		/* save original drive */

   174

		_dos_getdrive(&save);

   175

   176

		/* get available drive letters */

   177

   178

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

   179

		{

   180

			_dos_setdrive(disk, &total);

   181

			_dos_getdrive(&disk2);

   182

   183

			if (disk == disk2)

   184

			{

   185

				fios = FiosAlloc();

   186

				fios->type = FIOS_TYPE_DRIVE;

   187

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

   188

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

   189

				fios->title[2] = 0;

   190

			}

   191

		}

   192

   193

		_dos_setdrive(save, &total);

   194

	}

   195

   196

	*num = _fios_count;

   197

	return _fios_items;

   198

}

   199

   200

// Get a list of scenarios

   201

FiosItem *FiosGetScenarioList(int *num, int mode)

   202

{

   203

	FiosItem *fios;

   204

	DIR *dir;

   205

	struct dirent *dirent;

   206

	struct stat sb;

   207

	int sort_start;

   208

	char filename[MAX_PATH];

   209

   210

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

   211

		if (_fios_scn_path == NULL)

   212

			_fios_scn_path = malloc(MAX_PATH);

   213

		strcpy(_fios_scn_path, _path.scenario_dir);

   214

	}

   215

   216

	_fios_path = _fios_scn_path;

   217

   218

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

   219

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

   220

		fios = FiosAlloc();

   221

		fios->type = FIOS_TYPE_PARENT;

   222

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

   223

	}

   224

   225

	// Show subdirectories first

   226

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

   227

	if (dir != NULL) {

   228

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

   229

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

   230

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

   231

				if (S_ISDIR(sb.st_mode)) {

   232

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

   233

					{

   234

						fios = FiosAlloc();

   235

						fios->mtime = 0;

   236

						fios->type = FIOS_TYPE_DIR;

   237

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

   238

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

   239

					}

   240

				}

   241

			}

   242

		}

   243

		closedir(dir);

   244

	}

   245

   246

	// this is where to start sorting

   247

	sort_start = _fios_count;

   248

   249

	/*      Show scenario files

   250

	 *      .SCN    OpenTTD style scenario file

   251

	 *      .SV0    Transport Tycoon Deluxe (Patch) scenario

   252

	 *      .SS0    Transport Tycoon Deluxe preset scenario

   253

	 */

   254

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

   255

	if (dir != NULL) {

   256

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

   257

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

   258

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

   259

				if (!S_ISDIR(sb.st_mode)) {

   260

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

   261

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

   262

						*t = 0; // cut extension

   263

						fios = FiosAlloc();

   264

						fios->type = FIOS_TYPE_SCENARIO;

   265

						fios->mtime = sb.st_mtime;

   266

						fios->title[0] = 0;

   267

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

   268

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

   269

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

   270

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

   271

							*t = 0; // cut extension

   272

							fios = FiosAlloc();

   273

							fios->old_extension = ext-1;

   274

							fios->type = FIOS_TYPE_OLD_SCENARIO;

   275

							fios->mtime = sb.st_mtime;

   276

							GetOldScenarioGameName(fios->title, filename);

   277

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

   278

						}

   279

					}

   280

				}

   281

			}

   282

		}

   283

		closedir(dir);

   284

	}

   285

   286

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

   287

   288

	// Drives

   289

	if (mode != SLD_NEW_GAME)

   290

	{

   291

		unsigned save, disk, disk2, total;

   292

   293

		/* save original drive */

   294

		_dos_getdrive(&save);

   295

   296

		/* get available drive letters */

   297

   298

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

   299

		{

   300

			_dos_setdrive(disk, &total);

   301

			_dos_getdrive(&disk2);

   302

   303

			if (disk == disk2)

   304

			{

   305

				fios = FiosAlloc();

   306

				fios->type = FIOS_TYPE_DRIVE;

   307

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

   308

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

   309

				fios->title[2] = 0;

   310

			}

   311

		}

   312

   313

		_dos_setdrive(save, &total);

   314

	}

   315

   316

	*num = _fios_count;

   317

	return _fios_items;

   318

}

   319

   320

   321

// Free the list of savegames

   322

void FiosFreeSavegameList()

   323

{

   324

	free(_fios_items);

   325

	_fios_items = NULL;

   326

	_fios_alloc = _fios_count = 0;

   327

}

   328

   329

// Browse to

   330

char *FiosBrowseTo(const FiosItem *item)

   331

{

   332

	char *path = _fios_path;

   333

	char *s;

   334

   335

	switch(item->type) {

   336

	case FIOS_TYPE_DRIVE:

   337

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

   338

		break;

   339

   340

	case FIOS_TYPE_PARENT:

   341

		// Skip drive part

   342

		path += 3;

   343

		s = path;

   344

		while (*path) {

   345

			if (*path== '\\')

   346

				s = path;

   347

			path++;

   348

		}

   349

		*s = 0;

   350

		break;

   351

   352

	case FIOS_TYPE_DIR:

   353

		// Scan to end

   354

		while (*++path);

   355

		// Add backslash?

   356

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

   357

   358

		strcpy(path, item->name);

   359

		break;

   360

   361

	case FIOS_TYPE_FILE:

   362

		FiosMakeSavegameName(str_buffr, item->name);

   363

		return str_buffr;

   364

   365

	case FIOS_TYPE_OLDFILE:

   366

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

   367

		return str_buffr;

   368

   369

	case FIOS_TYPE_SCENARIO:

   370

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

   371

		return str_buffr;

   372

	case FIOS_TYPE_OLD_SCENARIO:

   373

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

   374

		return str_buffr;

   375

	}

   376

   377

	return NULL;

   378

}

   379

   380

// Get descriptive texts.

   381

// Returns a path as well as a

   382

//  string describing the path.

   383

StringID FiosGetDescText(const char **path)

   384

{

   385

	struct diskfree_t free;

   386

	char drive;

   387

   388

	*path = _fios_path;

   389

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

   390

   391

	_getdiskfree(drive, &free);

   392

   393

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

   394

	return STR_4005_BYTES_FREE;

   395

}

   396

   397

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

   398

{

   399

	if(_game_mode==GM_EDITOR)

   400

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

   401

	else

   402

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

   403

}

   404

   405

void FiosDelete(const char *name)

   406

{

   407

	char *path = str_buffr;

   408

	FiosMakeSavegameName(path, name);

   409

	unlink(path);

   410

}

   411

   412

const DriverDesc _video_driver_descs[] = {

   413

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

   414

#if defined(WITH_SDL)

   415

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

   416

#endif

   417

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

   418

	{	NULL,			NULL,						NULL,						0}

   419

};

   420

   421

const DriverDesc _sound_driver_descs[] = {

   422

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

   423

#if defined(WITH_SDL)

   424

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

   425

#endif

   426

	{	NULL,	NULL,					NULL,						0}

   427

};

   428

   429

const DriverDesc _music_driver_descs[] = {

   430

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

   431

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

   432

	{	NULL,		NULL,						NULL,						0}

   433

};

   434

   435

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

   436

	 Not needed for OS/2. */

   437

byte GetOSVersion()

   438

{

   439

	return 2;  // any arbitrary number bigger then 0

   440

}

   441

   442

bool FileExists(const char *filename)

   443

{

   444

	return access(filename, 0) == 0;

   445

}

   446

   447

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

   448

{

   449

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

   450

}

   451

   452

int GetLanguageList(char **languages, int max)

   453

{

   454

	DIR *dir;

   455

	struct dirent *dirent;

   456

	int num = 0;

   457

   458

	dir = opendir(_path.lang_dir);

   459

	if (dir != NULL) {

   460

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

   461

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

   462

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

   463

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

   464

				if (num == max) break;

   465

			}

   466

		}

   467

		closedir(dir);

   468

	}

   469

   470

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

   471

	return num;

   472

}

   473

   474

static void ChangeWorkingDirectory(char *exe)

   475

{

   476

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

   477

	if (s != NULL) {

   478

		*s = 0;

   479

		chdir(exe);

   480

		*s = '\\';

   481

	}

   482

}

   483

   484

void ShowInfo(const char *str)

   485

{