1

#include "stdafx.h"

     2

#include "ttd.h"

     3

     4

#include "vehicle.h"

     5

     6

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

     7

void InitializeVehiclesGuiList()

     8

{

     9

	bool *i;

    10

	for (i = _train_sort_dirty; i != endof(_train_sort_dirty); i++)

    11

		*i = true;

    12

    13

	for (i = _aircraft_sort_dirty; i != endof(_aircraft_sort_dirty); i++)

    14

		*i = true;

    15

    16

	for (i = _ship_sort_dirty; i != endof(_ship_sort_dirty); i++)

    17

		*i = true;

    18

    19

	for (i = _road_sort_dirty; i != endof(_road_sort_dirty); i++)

    20

		*i = true;

    21

    22

	for (i = _vehicle_sort_dirty; i != endof(_vehicle_sort_dirty); i++)

    23

		*i = true;

    24

    25

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

    26

}

    27

    28

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

    29

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

    30

{

    31

	uint32 ormod;

    32

    33

	// draw profit-based colored icons

    34

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

    35

		ormod = 0x3158000; // grey

    36

	else if(v->profit_last_year < 0)

    37

		ormod = 0x30b8000; //red

    38

	else if(v->profit_last_year < 10000)

    39

		ormod = 0x30a8000; // yellow

    40

	else

    41

		ormod = 0x30d8000; // green

    42

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

    43

}

    44

    45

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

    46

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

    47

{

    48

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

    49

}

    50

    51

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

    52

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

    53

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

    54

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

    55

*    STR_SV_TRAIN_NAME for trains or STR_SV_AIRCRAFT_NAME for aircraft

    56

*/

    57

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

    58

{

    59

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

    60

}

    61

    62

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

    63

{

    64

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

    65

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

    66

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

    67

    68

	if (r == 0) // if the sorting criteria had the same value, sort by unitnumber

    69

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

    70

    71

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

    72

}

    73

    74

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

    75

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

    76

{

    77

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

    78

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

    79

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

    80

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

    81

	char buf1[64] = "\0";

    82

	int r;

    83

    84

	if (va->string_id != _internal_name_sorter_id) {

    85

		SET_DPARAM16(0, va->string_id);

    86

		GetString(buf1, STR_0315);

    87

	}

    88

    89

	if ( cmp2->index != _last_vehicle_idx) {

    90

		_last_vehicle_idx = cmp2->index;

    91

		_bufcache[0] = '\0';

    92

		if (vb->string_id != _internal_name_sorter_id) {

    93

			SET_DPARAM16(0, vb->string_id);

    94

			GetString(_bufcache, STR_0315);

    95

		}

    96

	}

    97

    98

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

    99

   100

	if (r == 0) // if the sorting criteria had the same value, sort by unitnumber

   101

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

   102

   103

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

   104

}

   105

   106

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

   107

{

   108

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

   109

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

   110

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

   111

   112

	if (r == 0) // if the sorting criteria had the same value, sort by unitnumber

   113

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

   114

   115

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

   116

}

   117

   118

int CDECL VehicleProfitThisYearSorter(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->profit_this_year - vb->profit_this_year;

   123

   124

	if (r == 0) // if the sorting criteria had the same value, sort by unitnumber

   125

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

   126

   127

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

   128

}

   129

   130

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

   131

{

   132

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

   133

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

   134

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

   135

   136

	if (r == 0) // if the sorting criteria had the same value, sort by unitnumber

   137

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

   138

   139

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

   140

}

   141

   142

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

   143

{

   144

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

   145

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

   146

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

   147

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

   148

	int r = 0;

   149

	int i;

   150

	byte _cargo_counta[NUM_CARGO];

   151

	byte _cargo_countb[NUM_CARGO];

   152

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

   153

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

   154

   155

	do {

   156

		_cargo_counta[va->cargo_type]++;

   157

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

   158

   159

	do {

   160

		_cargo_countb[vb->cargo_type]++;

   161

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

   162

   163

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

   164

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

   165

		if (r != 0)

   166

			break;

   167

	}

   168

   169

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

   170

}

   171

   172

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

   173

{

   174

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

   175

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

   176

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

   177

   178

	if (r == 0) // if the sorting criteria had the same value, sort by unitnumber

   179

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

   180

   181

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

   182

}

   183

   184

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

   185

{

   186

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

   187

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

   188

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

   189

   190

	if (r == 0) // if the sorting criteria had the same value, sort by unitnumber

   191

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

   192

   193

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

   194

}