OpenTTD
vehiclelist.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of OpenTTD.
3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6  */
7 
10 #include "stdafx.h"
11 #include "train.h"
12 #include "vehiclelist.h"
13 #include "group.h"
14 
15 #include "safeguards.h"
16 
22 {
23  byte c = this->company == OWNER_NONE ? 0xF : (byte)this->company;
24  assert(c < (1 << 4));
25  assert(this->vtype < (1 << 2));
26  assert(this->index < (1 << 20));
27  assert(this->type < VLT_END);
28  assert_compile(VLT_END <= (1 << 3));
29 
30  return c << 28 | this->type << 23 | this->vtype << 26 | this->index;
31 }
32 
39 {
40  byte c = GB(data, 28, 4);
41  this->company = c == 0xF ? OWNER_NONE : (CompanyID)c;
42  this->type = (VehicleListType)GB(data, 23, 3);
43  this->vtype = (VehicleType)GB(data, 26, 2);
44  this->index = GB(data, 0, 20);
45 
46  return this->type < VLT_END;
47 }
48 
54 {
55  VehicleListIdentifier result;
56  bool ret = result.UnpackIfValid(data);
57  assert(ret);
58  return result;
59 }
60 
69 void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)
70 {
71  engines->clear();
72  if (wagons != nullptr && wagons != engines) wagons->clear();
73 
74  for (const Vehicle *v : Vehicle::Iterate()) {
75  /* General tests for all vehicle types */
76  if (v->type != type) continue;
77  if (v->tile != tile) continue;
78 
79  switch (type) {
80  case VEH_TRAIN: {
81  const Train *t = Train::From(v);
82  if (t->IsArticulatedPart() || t->IsRearDualheaded()) continue;
83  if (t->track != TRACK_BIT_DEPOT) continue;
84  if (wagons != nullptr && t->First()->IsFreeWagon()) {
85  if (individual_wagons || t->IsFreeWagon()) wagons->push_back(t);
86  continue;
87  }
88  break;
89  }
90 
91  default:
92  if (!v->IsInDepot()) continue;
93  break;
94  }
95 
96  if (!v->IsPrimaryVehicle()) continue;
97 
98  engines->push_back(v);
99  }
100 
101  /* Ensure the lists are not wasting too much space. If the lists are fresh
102  * (i.e. built within a command) then this will actually do nothing. */
103  engines->shrink_to_fit();
104  if (wagons != nullptr && wagons != engines) wagons->shrink_to_fit();
105 }
106 
114 {
115  list->clear();
116 
117  switch (vli.type) {
118  case VL_STATION_LIST:
119  for (const Vehicle *v : Vehicle::Iterate()) {
120  if (v->type == vli.vtype && v->IsPrimaryVehicle()) {
121  const Order *order;
122 
123  FOR_VEHICLE_ORDERS(v, order) {
124  if ((order->IsType(OT_GOTO_STATION) || order->IsType(OT_GOTO_WAYPOINT) || order->IsType(OT_IMPLICIT))
125  && order->GetDestination() == vli.index) {
126  list->push_back(v);
127  break;
128  }
129  }
130  }
131  }
132  break;
133 
134  case VL_SHARED_ORDERS: {
135  /* Add all vehicles from this vehicle's shared order list */
136  const Vehicle *v = Vehicle::GetIfValid(vli.index);
137  if (v == nullptr || v->type != vli.vtype || !v->IsPrimaryVehicle()) return false;
138 
139  for (; v != nullptr; v = v->NextShared()) {
140  list->push_back(v);
141  }
142  break;
143  }
144 
145  case VL_GROUP_LIST:
146  if (vli.index != ALL_GROUP) {
147  for (const Vehicle *v : Vehicle::Iterate()) {
148  if (v->type == vli.vtype && v->IsPrimaryVehicle() &&
149  v->owner == vli.company && GroupIsInGroup(v->group_id, vli.index)) {
150  list->push_back(v);
151  }
152  }
153  break;
154  }
155  FALLTHROUGH;
156 
157  case VL_STANDARD:
158  for (const Vehicle *v : Vehicle::Iterate()) {
159  if (v->type == vli.vtype && v->owner == vli.company && v->IsPrimaryVehicle()) {
160  list->push_back(v);
161  }
162  }
163  break;
164 
165  case VL_DEPOT_LIST:
166  for (const Vehicle *v : Vehicle::Iterate()) {
167  if (v->type == vli.vtype && v->IsPrimaryVehicle()) {
168  const Order *order;
169 
170  FOR_VEHICLE_ORDERS(v, order) {
171  if (order->IsType(OT_GOTO_DEPOT) && !(order->GetDepotActionType() & ODATFB_NEAREST_DEPOT) && order->GetDestination() == vli.index) {
172  list->push_back(v);
173  break;
174  }
175  }
176  }
177  }
178  break;
179 
180  default: return false;
181  }
182 
183  list->shrink_to_fit();
184  return true;
185 }
Owner
Enum for all companies/owners.
Definition: company_type.h:18
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:302
CompanyID company
The company associated with this list.
Definition: vehiclelist.h:32
The information about a vehicle list.
Definition: vehiclelist.h:29
Functions and type for generating vehicle lists.
Train vehicle type.
Definition: vehicle_type.h:24
Base for the train class.
Base class for groups and group functions.
bool GroupIsInGroup(GroupID search, GroupID group)
Test if GroupID group is a descendant of (or is) GroupID search.
Definition: group_cmd.cpp:858
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
Vehicle data structure.
Definition: vehicle_base.h:210
bool UnpackIfValid(uint32 data)
Unpack a VehicleListIdentifier from a single uint32.
Definition: vehiclelist.cpp:38
T * First() const
Get the first vehicle in the chain.
Definition: vehicle_base.h:996
void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)
Generate a list of vehicles inside a depot.
Definition: vehiclelist.cpp:69
bool GenerateVehicleSortList(VehicleList *list, const VehicleListIdentifier &vli)
Generate a list of vehicles based on window type.
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
OrderDepotActionFlags GetDepotActionType() const
What are we going to do when in the depot.
Definition: order_base.h:137
The tile has no ownership.
Definition: company_type.h:25
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
Definition: vehicle_base.h:431
uint32 index
A vehicle list type specific index.
Definition: vehiclelist.h:33
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:61
Definition of base types and functions in a cross-platform compatible way.
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
Definition: vehicle_base.h:890
A number of safeguards to prevent using unsafe methods.
static VehicleListIdentifier UnPack(uint32 data)
Decode a packed vehicle list identifier into a new one.
Definition: vehiclelist.cpp:53
bool IsRearDualheaded() const
Tell if we are dealing with the rear end of a multiheaded engine.
&#39;Train&#39; is either a loco or a wagon.
Definition: train.h:85
Bitflag for a depot.
Definition: track_type.h:56
DestinationID GetDestination() const
Gets the destination of this order.
Definition: order_base.h:94
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:340
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
uint32 Pack() const
Pack a VehicleListIdentifier in a single uint32.
Definition: vehiclelist.cpp:21
Send the vehicle to the nearest depot.
Definition: order_type.h:105
VehicleListType type
The type of vehicle list.
Definition: vehiclelist.h:30
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
VehicleListType
Vehicle List type flags.
Definition: vehiclelist.h:19
bool IsFreeWagon() const
Check if the vehicle is a free wagon (got no engine in front of it).
Vehicle * NextShared() const
Get the next vehicle of the shared vehicle chain.
Definition: vehicle_base.h:661
std::vector< const Vehicle * > VehicleList
A list of vehicles.
Definition: vehiclelist.h:53
VehicleType vtype
The vehicle type associated with this list.
Definition: vehiclelist.h:31
static const GroupID ALL_GROUP
All vehicles are in this group.
Definition: group_type.h:16