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

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

    10

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

    11

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

    12

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

    13

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

    14

}

    15

    16

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

    17

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

    18

{

    19

	uint32 ormod;

    20

    21

	// draw profit-based colored icons

    22

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

    23

		ormod = 0x3158000; // grey

    24

	else if(v->profit_last_year < 0)

    25

		ormod = 0x30b8000; //red

    26

	else if(v->profit_last_year < 10000)

    27

		ormod = 0x30a8000; // yellow

    28

	else

    29

		ormod = 0x30d8000; // green

    30

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

    31

}

    32

    33

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

    34

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

    35

{

    36

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

    37

}

    38

    39

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

    40

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

    41

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

    42

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

    43

*    STR_SV_TRAIN_NAME for trains or STR_SV_AIRCRAFT_NAME for aircraft

    44

*/

    45

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

    46

{

    47

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

    48

}

    49

    50

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

    51

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

    52

    53

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

    54

{

    55

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

    56

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

    57

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

    58

    59

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

    60

}

    61

    62

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

    63

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

    64

{

    65

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

    66

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

    67

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

    68

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

    69

	char buf1[64] = "\0";

    70

	int r;

    71

    72

	if (va->string_id != _internal_name_sorter_id) {

    73

		SET_DPARAM16(0, va->string_id);

    74

		GetString(buf1, STR_0315);

    75

	}

    76

    77

	if ( cmp2->index != _last_vehicle_idx) {

    78

		_last_vehicle_idx = cmp2->index;

    79

		_bufcache[0] = '\0';

    80

		if (vb->string_id != _internal_name_sorter_id) {

    81

			SET_DPARAM16(0, vb->string_id);

    82

			GetString(_bufcache, STR_0315);

    83

		}

    84

	}

    85

    86

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

    87

    88

	VEHICLEUNITNUMBERSORTER(r, va, vb);

    89

    90

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

    91

}

    92

    93

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

    94

{

    95

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

    96

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

    97

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

    98

    99

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   100

   101

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

   102

}

   103

   104

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

   105

{

   106

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

   107

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

   108

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

   109

   110

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   111

   112

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

   113

}

   114

   115

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

   116

{

   117

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

   118

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

   119

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

   120

   121

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   122

   123

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

   124

}

   125

   126

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

   127

{

   128

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

   129

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

   130

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

   131

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

   132

	int r = 0;

   133

	int i;

   134

	byte _cargo_counta[NUM_CARGO];

   135

	byte _cargo_countb[NUM_CARGO];

   136

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

   137

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

   138

   139

	do {

   140

		_cargo_counta[va->cargo_type]++;

   141

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

   142

   143

	do {

   144

		_cargo_countb[vb->cargo_type]++;

   145

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

   146

   147

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

   148

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

   149

		if (r != 0)

   150

			break;

   151

	}

   152

   153

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

   154

}

   155

   156

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

   157

{

   158

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

   159

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

   160

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

   161

   162

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   163

   164

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

   165

}

   166

   167

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

   168

{

   169

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

   170

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

   171

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

   172

   173

	VEHICLEUNITNUMBERSORTER(r, va, vb);

   174

   175

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

   176

}