1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "vehicle.h"

     5

     6

VehicleSortListingTypeFunctions * const _vehicle_sorter[] = {

     7

	&VehicleUnsortedSorter,

     8

	&VehicleNumberSorter,

     9

	&VehicleNameSorter,

    10

	&VehicleAgeSorter,

    11

	&VehicleProfitThisYearSorter,

    12

	&VehicleProfitLastYearSorter,

    13

	&VehicleCargoSorter,

    14

	&VehicleReliabilitySorter,

    15

	&VehicleMaxSpeedSorter

    16

};

    17

    18

const StringID _vehicle_sort_listing[] = {

    19

	STR_SORT_BY_UNSORTED,

    20

	STR_SORT_BY_NUMBER,

    21

	STR_SORT_BY_DROPDOWN_NAME,

    22

	STR_SORT_BY_AGE,

    23

	STR_SORT_BY_PROFIT_THIS_YEAR,

    24

	STR_SORT_BY_PROFIT_LAST_YEAR,

    25

	STR_SORT_BY_TOTAL_CAPACITY_PER_CARGOTYPE,

    26

	STR_SORT_BY_RELIABILITY,

    27

	STR_SORT_BY_MAX_SPEED,

    28

	INVALID_STRING_ID

    29

};

    30

    31

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

    32

void InitializeVehiclesGuiList()

    33

{

    34

	memset(_train_sort_dirty, true, sizeof(_train_sort_dirty));

    35

	memset(_aircraft_sort_dirty, true, sizeof(_aircraft_sort_dirty));

    36

	memset(_ship_sort_dirty, true, sizeof(_ship_sort_dirty));

    37

	memset(_road_sort_dirty, true, sizeof(_road_sort_dirty));

    38

	memset(_vehicle_sort_dirty, true, sizeof(_vehicle_sort_dirty));

    39

}

    40

    41

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

    42

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

    43

{

    44

	uint32 ormod;

    45

    46

	// draw profit-based colored icons

    47

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

    48

		ormod = 0x3158000; // grey

    49

	else if(v->profit_last_year < 0)

    50

		ormod = 0x30b8000; //red

    51

	else if(v->profit_last_year < 10000)

    52

		ormod = 0x30a8000; // yellow

    53

	else

    54

		ormod = 0x30d8000; // green

    55

	DrawSprite((SPR_OPENTTD_BASE + 10) | ormod, x, y);

    56

}

    57

    58

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

    59

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

    60

{

    61

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

    62

}

    63

    64

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

    65

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

    66

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

    67

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

    68

*    STR_SV_TRAIN_NAME for trains or STR_SV_AIRCRAFT_NAME for aircraft

    69

*/

    70

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

    71

{

    72

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

    73

}

    74

    75

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

    76

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

    77

    78

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

    79

{

    80

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

    81

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

    82

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

    83

    84

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

    85

}

    86

    87

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

    88

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

    89

{

    90

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

    91

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

    92

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

    93

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

    94

	char buf1[64] = "\0";

    95

	int r;

    96

    97

	if (va->string_id != _internal_name_sorter_id) {

    98

		SET_DPARAM16(0, va->string_id);

    99

		GetString(buf1, STR_0315);

   100

	}

   101

   102

	if ( cmp2->index != _last_vehicle_idx) {

   103

		_last_vehicle_idx = cmp2->index;

   104

		_bufcache[0] = '\0';

   105

		if (vb->string_id != _internal_name_sorter_id) {

   106

			SET_DPARAM16(0, vb->string_id);

   107

			GetString(_bufcache, STR_0315);

   108

		}

   109

	}

   110

   111

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

   112

   113

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   114

   115

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

   116

}

   117

   118

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

   119

{

   120

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

   121

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

   122

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

   123

   124

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   125

   126

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

   127

}

   128

   129

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

   130

{

   131

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

   132

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

   133

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

   134

   135

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   136

   137

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

   138

}

   139

   140

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

   141

{

   142

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

   143

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

   144

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

   145

   146

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   147

   148

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

   149

}

   150

   151

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

   152

{

   153

	// FIXME - someone write a normal cargo sorter that also works by cargo_cap,

   154

	// FIXME - since I seem to be unable to do so :S

   155

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

   156

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

   157

	int r = 0;

   158

	int i;

   159

	byte _cargo_counta[NUM_CARGO];

   160

	byte _cargo_countb[NUM_CARGO];

   161

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

   162

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

   163

   164

	do {

   165

		_cargo_counta[va->cargo_type]++;

   166

	} while ( (va = va->next) != NULL);

   167

   168

	do {

   169

		_cargo_countb[vb->cargo_type]++;

   170

	} while ( (vb = vb->next) != NULL);

   171

   172

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

   173

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

   174

		if (r != 0)

   175

			break;

   176

	}

   177

   178

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

   179

}

   180

   181

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

   182

{

   183

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

   184

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

   185

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

   186

   187

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   188

   189

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

   190

}

   191

   192

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

   193

{

   194

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

   195

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

   196

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

   197

   198

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   199

   200

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

   201

}