1

/* $Id$ */

     2

     3

/** @file vehiclelist.cpp Lists of vehicles. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "vehicle_type.h"

     8

#include "vehicle_func.h"

     9

#include "vehicle_base.h"

    10

#include "vehicle_gui.h"

    11

#include "core/alloc_func.hpp"

    12

#include "train.h"

    13

#include "vehiclelist.h"

    14

    15

/**

    16

 * Generate a list of vehicles inside a depot.

    17

 * @param type    Type of vehicle

    18

 * @param tile    The tile the depot is located on

    19

 * @param engines Pointer to list to add vehicles to

    20

 * @param wagons  Pointer to list to add wagons to (can be NULL)

    21

 * @param individual_wagons If true add every wagon to #wagons which is not attached to an engine. If false only add the first wagon of every row.

    22

 */

    23

void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)

    24

{

    25

	engines->Clear();

    26

	if (wagons != NULL && wagons != engines) wagons->Clear();

    27

    28

	const Vehicle *v;

    29

	FOR_ALL_VEHICLES(v) {

    30

		/* General tests for all vehicle types */

    31

		if (v->type != type) continue;

    32

		if (v->tile != tile) continue;

    33

    34

		switch (type) {

    35

			case VEH_TRAIN:

    36

				if (IsArticulatedPart(v) || IsRearDualheaded(v)) continue;

    37

				if (v->u.rail.track != TRACK_BIT_DEPOT) continue;

    38

				if (wagons != NULL && IsFreeWagon(v->First())) {

    39

					if (individual_wagons || IsFreeWagon(v)) *wagons->Append() = v;

    40

					continue;

    41

				}

    42

				break;

    43

    44

			default:

    45

				if (!v->IsInDepot()) continue;

    46

				break;

    47

		}

    48

    49

		if (!v->IsPrimaryVehicle()) continue;

    50

    51

		*engines->Append() = v;

    52

	}

    53

    54

	/* Ensure the lists are not wasting too much space. If the lists are fresh

    55

	 * (i.e. built within a command) then this will actually do nothing. */

    56

	engines->Compact();

    57

	if (wagons != NULL && wagons != engines) wagons->Compact();

    58

}

    59

    60

/**

    61

 * Generate a list of vehicles based on window type.

    62

 * @param list        Pointer to list to add vehicles to

    63

 * @param type        Type of vehicle

    64

 * @param owner       Company to generate list for

    65

 * @param index       This parameter has different meanings depending on window_type

    66

 *    <ul>

    67

 *      <li>VLW_STATION_LIST:  index of station to generate a list for</li>

    68

 *      <li>VLW_SHARED_ORDERS: index of order to generate a list for<li>

    69

 *      <li>VLW_STANDARD: not used<li>

    70

 *      <li>VLW_DEPOT_LIST: TileIndex of the depot/hangar to make the list for</li>

    71

 *      <li>VLW_GROUP_LIST: index of group to generate a list for</li>

    72

 *      <li>VLW_WAYPOINT_LIST: index of waypoint to generate a list for</li>

    73

 *    </ul>

    74

 * @param window_type The type of window the list is for, using the VLW_ flags in vehicle_gui.h

    75

 */

    76

void GenerateVehicleSortList(VehicleList *list, VehicleType type, Owner owner, uint32 index, uint16 window_type)

    77

{

    78

	list->Clear();

    79

    80

	const Vehicle *v;

    81

    82

	switch (window_type) {

    83

		case VLW_STATION_LIST:

    84

			FOR_ALL_VEHICLES(v) {

    85

				if (v->type == type && v->IsPrimaryVehicle()) {

    86

					const Order *order;

    87

    88

					FOR_VEHICLE_ORDERS(v, order) {

    89

						if (order->IsType(OT_GOTO_STATION) && order->GetDestination() == index) {

    90

							*list->Append() = v;

    91

							break;

    92

						}

    93

					}

    94

				}

    95

			}

    96

			break;

    97

    98

		case VLW_SHARED_ORDERS:

    99

			/* Add all vehicles from this vehicle's shared order list */

   100

			for (v = GetVehicle(index); v != NULL; v = v->NextShared()) {

   101

				*list->Append() = v;

   102

			}

   103

			break;

   104

   105

		case VLW_STANDARD:

   106

			FOR_ALL_VEHICLES(v) {

   107

				if (v->type == type && v->owner == owner && v->IsPrimaryVehicle()) {

   108

					*list->Append() = v;

   109

				}

   110

			}

   111

			break;

   112

   113

		case VLW_DEPOT_LIST:

   114

			FOR_ALL_VEHICLES(v) {

   115

				if (v->type == type && v->IsPrimaryVehicle()) {

   116

					const Order *order;

   117

   118

					FOR_VEHICLE_ORDERS(v, order) {

   119

						if (order->IsType(OT_GOTO_DEPOT) && order->GetDestination() == index) {

   120

							*list->Append() = v;

   121

							break;

   122

						}

   123

					}

   124

				}

   125

			}

   126

			break;

   127

   128

		case VLW_WAYPOINT_LIST:

   129

			FOR_ALL_VEHICLES(v) {

   130

				if (v->type == type && v->IsPrimaryVehicle()) {

   131

					const Order *order;

   132

   133

					FOR_VEHICLE_ORDERS(v, order) {

   134

						if (order->IsType(OT_GOTO_WAYPOINT) && order->GetDestination() == index) {

   135

							*list->Append() = v;

   136

							break;

   137

						}

   138

					}

   139

				}

   140

			}

   141

			break;

   142

   143

		case VLW_GROUP_LIST:

   144

			FOR_ALL_VEHICLES(v) {

   145

				if (v->type == type && v->IsPrimaryVehicle() &&

   146

						v->owner == owner && v->group_id == index) {

   147

					*list->Append() = v;

   148

				}

   149

			}

   150

			break;

   151

   152

		default: NOT_REACHED(); break;

   153

	}

   154

   155

	list->Compact();

   156

}