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 (*(SortStruct*)a).owner - (*(SortStruct*)b).owner;

    49

}

    50

    51

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

    52

    53

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

    54

* 1. (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

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

    57

*/

    58

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

    59

{

    60

	SortStruct *cmp1 = (SortStruct*)a;

    61

	SortStruct *cmp2 = (SortStruct*)b;

    62

	Vehicle *v;

    63

	char buf1[64] = "\0";

    64

	int r;

    65

    66

	v = DEREF_VEHICLE(cmp1->index);

    67

	if (v->string_id != _internal_name_sorter_id) {

    68

		SET_DPARAM16(0, v->string_id);

    69

		GetString(buf1, STR_0315);

    70

	}

    71

    72

	if ( cmp2->index != _last_vehicle_idx) {

    73

		_last_vehicle_idx = cmp2->index;

    74

		v = DEREF_VEHICLE(cmp2->index);

    75

		_bufcache[0] = '\0';

    76

		if (v->string_id != _internal_name_sorter_id) {

    77

			SET_DPARAM16(0, v->string_id);

    78

			GetString(_bufcache, STR_0315);

    79

		}

    80

	}

    81

    82

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

    83

	if (_internal_sort_order & 1) r = -r;

    84

	return r;

    85

}

    86

    87

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

    88

* 1. (byte)_internal_sort_type:		the criteria by which to sort these vehicles (number, age, etc)

    89

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

    90

*/

    91

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

    92

{

    93

	SortStruct *cmp1 = (SortStruct*)a;

    94

	SortStruct *cmp2 = (SortStruct*)b;

    95

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

    96

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

    97

	int r;

    98

    99

	switch (_internal_sort_type) {

   100

		case SORT_BY_UNSORTED: /* Sort unsorted */

   101

			return va->index - vb->index;

   102

		case SORT_BY_NUMBER: /* Sort by Number */

   103

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

   104

			break;

   105

		/* case SORT_BY_NAME: Sort by Name (VehicleNameSorter)*/

   106

		case SORT_BY_AGE: /* Sort by Age */

   107

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

   108

			break;

   109

		case SORT_BY_PROFIT_THIS_YEAR: /* Sort by Profit this year */

   110

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

   111

			break;

   112

		case SORT_BY_PROFIT_LAST_YEAR: /* Sort by Profit last year */

   113

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

   114

			break;

   115

		case SORT_BY_TOTAL_CAPACITY_PER_CARGOTYPE: { /* Sort by Total capacity per cargotype */

   116

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

   117

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

   118

			Vehicle *ua = va;

   119

			Vehicle *ub = vb;

   120

			int i;

   121

			byte _cargo_counta[NUM_CARGO];

   122

			byte _cargo_countb[NUM_CARGO];

   123

			do {

   124

				_cargo_counta[ua->cargo_type]++;

   125

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

   126

			do {

   127

				_cargo_countb[ub->cargo_type]++;

   128

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

   129

   130

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

   131

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

   132

				if (r != 0)

   133

					break;

   134

			}

   135

		} break;

   136

		case SORT_BY_RELIABILITY: /* Sort by Reliability */

   137

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

   138

			break;

   139

		case SORT_BY_MAX_SPEED: /* Sort by Max speed */

   140

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

   141

			break;

   142

		default: NOT_REACHED();

   143

	}

   144

   145

	if (_internal_sort_order & 1) r = -r;

   146

	return r;

   147

}