1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "vehicle.h"

     5

#include "window.h"

     6

     7

VehicleSortListingTypeFunctions * const _vehicle_sorter[] = {

     8

	&VehicleUnsortedSorter,

     9

	&VehicleNumberSorter,

    10

	&VehicleNameSorter,

    11

	&VehicleAgeSorter,

    12

	&VehicleProfitThisYearSorter,

    13

	&VehicleProfitLastYearSorter,

    14

	&VehicleCargoSorter,

    15

	&VehicleReliabilitySorter,

    16

	&VehicleMaxSpeedSorter

    17

};

    18

    19

const StringID _vehicle_sort_listing[] = {

    20

	STR_SORT_BY_UNSORTED,

    21

	STR_SORT_BY_NUMBER,

    22

	STR_SORT_BY_DROPDOWN_NAME,

    23

	STR_SORT_BY_AGE,

    24

	STR_SORT_BY_PROFIT_THIS_YEAR,

    25

	STR_SORT_BY_PROFIT_LAST_YEAR,

    26

	STR_SORT_BY_TOTAL_CAPACITY_PER_CARGOTYPE,

    27

	STR_SORT_BY_RELIABILITY,

    28

	STR_SORT_BY_MAX_SPEED,

    29

	INVALID_STRING_ID

    30

};

    31

    32

void RebuildVehicleLists(void)

    33

{

    34

	Window *w;

    35

    36

	for (w = _windows; w != _last_window; ++w)

    37

		switch (w->window_class) {

    38

			case WC_TRAINS_LIST:

    39

			case WC_ROADVEH_LIST:

    40

			case WC_SHIPS_LIST:

    41

			case WC_AIRCRAFT_LIST:

    42

				WP(w, vehiclelist_d).flags |= VL_REBUILD;

    43

				SetWindowDirty(w);

    44

				break;

    45

    46

			default:

    47

				break;

    48

		}

    49

}

    50

    51

void ResortVehicleLists(void)

    52

{

    53

	Window *w;

    54

    55

	for (w = _windows; w != _last_window; ++w)

    56

		switch (w->window_class) {

    57

			case WC_TRAINS_LIST:

    58

			case WC_ROADVEH_LIST:

    59

			case WC_SHIPS_LIST:

    60

			case WC_AIRCRAFT_LIST:

    61

				WP(w, vehiclelist_d).flags |= VL_RESORT;

    62

				SetWindowDirty(w);

    63

				break;

    64

    65

			default:

    66

				break;

    67

		}

    68

}

    69

    70

void BuildVehicleList(vehiclelist_d *vl, int type, int owner, int station)

    71

{

    72

	SortStruct sort_list[NUM_NORMAL_VEHICLES];

    73

	int subtype = (type != VEH_Aircraft) ? 0 : 2;

    74

	int n = 0;

    75

	int i;

    76

    77

	if (!(vl->flags & VL_REBUILD)) return;

    78

    79

	DEBUG(misc, 1) ("Building vehicle list for player %d station %d...",

    80

		owner, station);	

    81

    82

	if (station != -1) {

    83

		const Vehicle *v;

    84

		FOR_ALL_VEHICLES(v) {

    85

			if (v->type == type && v->subtype <= subtype) {

    86

				const Order *ord;

    87

				for (ord = v->schedule_ptr; ord->type != OT_NOTHING; ++ord)

    88

					if (ord->type == OT_GOTO_STATION && ord->station == station) {

    89

						sort_list[n].index = v - _vehicles;

    90

						sort_list[n].owner = v->owner;

    91

						++n;

    92

						break;

    93

					}

    94

			}

    95

		}

    96

	} else {

    97

		const Vehicle *v;

    98

		FOR_ALL_VEHICLES(v) {

    99

			if (v->type == type && v->subtype <= subtype && v->owner == owner) {

   100

				sort_list[n].index = v - _vehicles;

   101

				sort_list[n].owner = v->owner;

   102

				++n;

   103

			}

   104

		}

   105

	}

   106

   107

	vl->sort_list = realloc(vl->sort_list, n * sizeof(vl->sort_list[0])); /* XXX unchecked malloc */

   108

	vl->list_length = n;

   109

   110

	for (i = 0; i < n; ++i)

   111

		vl->sort_list[i] = sort_list[i];

   112

   113

	vl->flags &= ~VL_REBUILD;

   114

	vl->flags |= VL_RESORT;

   115

}

   116

   117

void SortVehicleList(vehiclelist_d *vl)

   118

{

   119

	if (!(vl->flags & VL_RESORT)) return;

   120

   121

	_internal_sort_order = vl->flags & VL_DESC;

   122

	_internal_name_sorter_id = STR_SV_TRAIN_NAME;

   123

	_last_vehicle_idx = 0; // used for "cache" in namesorting

   124

	qsort(vl->sort_list, vl->list_length, sizeof(vl->sort_list[0]),

   125

		_vehicle_sorter[vl->sort_type]);

   126

   127

	vl->resort_timer = DAY_TICKS * PERIODIC_RESORT_DAYS;

   128

	vl->flags &= ~VL_RESORT;

   129

}

   130

   131

   132

/* General Vehicle GUI based procedures that are independent of vehicle types */

   133

void InitializeVehiclesGuiList()

   134

{

   135

}

   136

   137

// draw the vehicle profit button in the vehicle list window.

   138

void DrawVehicleProfitButton(Vehicle *v, int x, int y)

   139

{

   140

	uint32 ormod;

   141

   142

	// draw profit-based colored icons

   143

	if(v->age <= 365 * 2)

   144

		ormod = 0x3158000; // grey

   145

	else if(v->profit_last_year < 0)

   146

		ormod = 0x30b8000; //red

   147

	else if(v->profit_last_year < 10000)

   148

		ormod = 0x30a8000; // yellow

   149

	else

   150

		ormod = 0x30d8000; // green

   151

	DrawSprite((SPR_BLOT) | ormod, x, y);

   152

}

   153

   154

/************ Sorter functions *****************/

   155

int CDECL GeneralOwnerSorter(const void *a, const void *b)

   156

{

   157

	return (*(const SortStruct*)a).owner - (*(const SortStruct*)b).owner;

   158

}

   159

   160

/* Variables you need to set before calling this function!

   161

* 1. (byte)_internal_sort_type:					sorting criteria to sort on

   162

* 2. (bool)_internal_sort_order:				sorting order, descending/ascending

   163

* 3. (uint32)_internal_name_sorter_id:	default StringID of the vehicle when no name is set. eg

   164

*    STR_SV_TRAIN_NAME for trains or STR_SV_AIRCRAFT_NAME for aircraft

   165

*/

   166

int CDECL VehicleUnsortedSorter(const void *a, const void *b)

   167

{

   168

	return DEREF_VEHICLE((*(const SortStruct*)a).index)->index - DEREF_VEHICLE((*(const SortStruct*)b).index)->index;

   169

}

   170

   171

// if the sorting criteria had the same value, sort vehicle by unitnumber

   172

#define VEHICLEUNITNUMBERSORTER(r, a, b) {if (r == 0) {r = a->unitnumber - b->unitnumber;}}

   173

   174

int CDECL VehicleNumberSorter(const void *a, const void *b)

   175

{

   176

	const Vehicle *va = DEREF_VEHICLE((*(const SortStruct*)a).index);

   177

	const Vehicle *vb = DEREF_VEHICLE((*(const SortStruct*)b).index);

   178

	int r = va->unitnumber - vb->unitnumber;

   179

   180

	return (_internal_sort_order & 1) ? -r : r;

   181

}

   182

   183

static char _bufcache[64];	// used together with _last_vehicle_idx to hopefully speed up stringsorting

   184

int CDECL VehicleNameSorter(const void *a, const void *b)

   185

{

   186

	const SortStruct *cmp1 = (const SortStruct*)a;

   187

	const SortStruct *cmp2 = (const SortStruct*)b;

   188

	const Vehicle *va = DEREF_VEHICLE(cmp1->index);

   189

	const Vehicle *vb = DEREF_VEHICLE(cmp2->index);

   190

	char buf1[64] = "\0";

   191

	int r;

   192

   193

	if (va->string_id != _internal_name_sorter_id) {

   194

		SetDParam(0, va->string_id);

   195

		GetString(buf1, STR_0315);

   196

	}

   197

   198

	if ( cmp2->index != _last_vehicle_idx) {

   199

		_last_vehicle_idx = cmp2->index;

   200

		_bufcache[0] = '\0';

   201

		if (vb->string_id != _internal_name_sorter_id) {

   202

			SetDParam(0, vb->string_id);

   203

			GetString(_bufcache, STR_0315);

   204

		}

   205

	}

   206

   207

	r =  strcmp(buf1, _bufcache);	// sort by name

   208

   209

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   210

   211

	return (_internal_sort_order & 1) ? -r : r;

   212

}

   213

   214

int CDECL VehicleAgeSorter(const void *a, const void *b)

   215

{

   216

	const Vehicle *va = DEREF_VEHICLE((*(const SortStruct*)a).index);

   217

	const Vehicle *vb = DEREF_VEHICLE((*(const SortStruct*)b).index);

   218

	int r = va->age - vb->age;

   219

   220

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   221

   222

	return (_internal_sort_order & 1) ? -r : r;

   223

}

   224

   225

int CDECL VehicleProfitThisYearSorter(const void *a, const void *b)

   226

{

   227

	const Vehicle *va = DEREF_VEHICLE((*(const SortStruct*)a).index);

   228

	const Vehicle *vb = DEREF_VEHICLE((*(const SortStruct*)b).index);

   229

	int r = va->profit_this_year - vb->profit_this_year;

   230

   231

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   232

   233

	return (_internal_sort_order & 1) ? -r : r;

   234

}

   235

   236

int CDECL VehicleProfitLastYearSorter(const void *a, const void *b)

   237

{

   238

	const Vehicle *va = DEREF_VEHICLE((*(const SortStruct*)a).index);

   239

	const Vehicle *vb = DEREF_VEHICLE((*(const SortStruct*)b).index);

   240

	int r = va->profit_last_year - vb->profit_last_year;

   241

   242

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   243

   244

	return (_internal_sort_order & 1) ? -r : r;

   245

}

   246

   247

int CDECL VehicleCargoSorter(const void *a, const void *b)

   248

{

   249

	const Vehicle *va = DEREF_VEHICLE((*(const SortStruct*)a).index);

   250

	const Vehicle *vb = DEREF_VEHICLE((*(const SortStruct*)b).index);

   252

	int r = 0;

   253

	int i;

   256

	memset(_cargo_counta, 0, sizeof(_cargo_counta));

   257

	memset(_cargo_countb, 0, sizeof(_cargo_countb));

   258

   261

   264

   265

	for (i = 0; i < NUM_CARGO; i++) {

   266

		r = _cargo_counta[i] - _cargo_countb[i];

   267

		if (r != 0)

   268

			break;

   269

	}

   270

   273

	return (_internal_sort_order & 1) ? -r : r;

   274

}

   275

   276

int CDECL VehicleReliabilitySorter(const void *a, const void *b)

   277

{

   278

	const Vehicle *va = DEREF_VEHICLE((*(const SortStruct*)a).index);

   279

	const Vehicle *vb = DEREF_VEHICLE((*(const SortStruct*)b).index);

   280

	int r = va->reliability - vb->reliability;

   281

   282

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   283

   284

	return (_internal_sort_order & 1) ? -r : r;

   285

}

   286

   287

int CDECL VehicleMaxSpeedSorter(const void *a, const void *b)

   288

{

   289

	const Vehicle *va = DEREF_VEHICLE((*(const SortStruct*)a).index);

   290

	const Vehicle *vb = DEREF_VEHICLE((*(const SortStruct*)b).index);

   291

	int r = va->max_speed - vb->max_speed;

   292

   293

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   294

   295

	return (_internal_sort_order & 1) ? -r : r;

   296

}