src/vehiclelist.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file vehiclelist.cpp Lists of vehicles. */
  11
  12 #include "stdafx.h"
  13 #include "train.h"
  14 #include "vehiclelist.h"
  15 #include "group.h"
  16 #include "tracerestrict.h"
  17
  18 #include "safeguards.h"
  19
  20 /**
  21  * Pack a VehicleListIdentifier in a single uint32.
  22  * @return The packed identifier.
  23  */
  24 uint32 VehicleListIdentifier::Pack() const
  25 {
  26         byte c = this->company == OWNER_NONE ? 0xF : (byte)this->company;
  27         assert(c             < (1 <<  4));
  28         assert(this->vtype   < (1 <<  2));
  29         assert(this->index   < (1 << 20));
  30         assert(this->type    < VLT_END);
  31         assert_compile(VLT_END <= (1 <<  3));
  32
  33         return c << 28 | this->type << 23 | this->vtype << 26 | this->index;
  34 }
  35
  36 /**
  37  * Unpack a VehicleListIdentifier from a single uint32.
  38  * @param data The data to unpack.
  39  * @return true iff the data was valid (enough).
  40  */
  41 bool VehicleListIdentifier::UnpackIfValid(uint32 data)
  42 {
  43         byte c        = GB(data, 28, 4);
  44         this->company = c == 0xF ? OWNER_NONE : (CompanyID)c;
  45         this->type    = (VehicleListType)GB(data, 23, 3);
  46         this->vtype   = (VehicleType)GB(data, 26, 2);
  47         this->index   = GB(data, 0, 20);
  48
  49         return this->type < VLT_END;
  50 }
  51
  52 /**
  53  * Decode a packed vehicle list identifier into a new one.
  54  * @param data The data to unpack.
  55  */
  56 /* static */ VehicleListIdentifier VehicleListIdentifier::UnPack(uint32 data)
  57 {
  58         VehicleListIdentifier result;
  59         bool ret = result.UnpackIfValid(data);
  60         assert(ret);
  61         return result;
  62 }
  63
  64 /**
  65  * Generate a list of vehicles inside a depot.
  66  * @param type    Type of vehicle
  67  * @param tile    The tile the depot is located on
  68  * @param engines Pointer to list to add vehicles to
  69  * @param wagons  Pointer to list to add wagons to (can be NULL)
  70  * @param individual_wagons If true add every wagon to \a wagons which is not attached to an engine. If false only add the first wagon of every row.
  71  */
  72 void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)
  73 {
  74         engines->Clear();
  75         if (wagons != NULL && wagons != engines) wagons->Clear();
  76
  77         const Vehicle *v;
  78         FOR_ALL_VEHICLES(v) {
  79                 /* General tests for all vehicle types */
  80                 if (v->type != type) continue;
  81                 if (v->tile != tile) continue;
  82
  83                 switch (type) {
  84                         case VEH_TRAIN: {
  85                                 const Train *t = Train::From(v);
  86                                 if (t->IsArticulatedPart() || t->IsRearDualheaded()) continue;
  87                                 if (t->track != TRACK_BIT_DEPOT) continue;
  88                                 if (wagons != NULL && t->First()->IsFreeWagon()) {
  89                                         if (individual_wagons || t->IsFreeWagon()) *wagons->Append() = t;
  90                                         continue;
  91                                 }
  92                                 break;
  93                         }
  94
  95                         default:
  96                                 if (!v->IsInDepot()) continue;
  97                                 break;
  98                 }
  99
 100                 if (!v->IsPrimaryVehicle()) continue;
 101
 102                 *engines->Append() = v;
 103         }
 104
 105         /* Ensure the lists are not wasting too much space. If the lists are fresh
 106          * (i.e. built within a command) then this will actually do nothing. */
 107         engines->Compact();
 108         if (wagons != NULL && wagons != engines) wagons->Compact();
 109 }
 110
 111 /**
 112  * Generate a list of vehicles based on window type.
 113  * @param list Pointer to list to add vehicles to
 114  * @param vli  The identifier of this vehicle list.
 115  * @return false if invalid list is requested
 116  */
 117 bool GenerateVehicleSortList(VehicleList *list, const VehicleListIdentifier &vli)
 118 {
 119         list->Clear();
 120
 121         const Vehicle *v;
 122
 123         auto fill_all_vehicles = [&]() {
 124                 FOR_ALL_VEHICLES(v) {
 125                         if (!HasBit(v->subtype, GVSF_VIRTUAL) && v->type == vli.vtype && v->owner == vli.company && v->IsPrimaryVehicle()) {
 126                                 *list->Append() = v;
 127                         }
 128                 }
 129         };
 130
 131         switch (vli.type) {
 132                 case VL_STATION_LIST:
 133                         FOR_ALL_VEHICLES(v) {
 134                                 if (v->type == vli.vtype && v->IsPrimaryVehicle()) {
 135                                         const Order *order;
 136
 137                                         FOR_VEHICLE_ORDERS(v, order) {
 138                                                 if ((order->IsType(OT_GOTO_STATION) || order->IsType(OT_GOTO_WAYPOINT) || order->IsType(OT_IMPLICIT))
 139                                                                 && order->GetDestination() == vli.index) {
 140                                                         *list->Append() = v;
 141                                                         break;
 142                                                 }
 143                                         }
 144                                 }
 145                         }
 146                         break;
 147
 148                 case VL_SHARED_ORDERS:
 149                         /* Add all vehicles from this vehicle's shared order list */
 150                         v = Vehicle::GetIfValid(vli.index);
 151                         if (v == NULL || v->type != vli.vtype || !v->IsPrimaryVehicle()) return false;
 152
 153                         for (; v != NULL; v = v->NextShared()) {
 154                                 *list->Append() = v;
 155                         }
 156                         break;
 157
 158                 case VL_GROUP_LIST:
 159                         if (vli.index != ALL_GROUP) {
 160                                 FOR_ALL_VEHICLES(v) {
 161                                         if (!HasBit(v->subtype, GVSF_VIRTUAL) && v->type == vli.vtype && v->IsPrimaryVehicle() &&
 162                                                         v->owner == vli.company && GroupIsInGroup(v->group_id, vli.index)) {
 163                                                 *list->Append() = v;
 164                                         }
 165                                 }
 166                                 break;
 167                         }
 168                         fill_all_vehicles();
 169                         break;
 170
 171                 case VL_STANDARD:
 172                         fill_all_vehicles();
 173                         break;
 174
 175                 case VL_DEPOT_LIST:
 176                         FOR_ALL_VEHICLES(v) {
 177                                 if (v->type == vli.vtype && v->IsPrimaryVehicle()) {
 178                                         const Order *order;
 179
 180                                         FOR_VEHICLE_ORDERS(v, order) {
 181                                                 if (order->IsType(OT_GOTO_DEPOT) && !(order->GetDepotActionType() & ODATFB_NEAREST_DEPOT) && order->GetDestination() == vli.index) {
 182                                                         *list->Append() = v;
 183                                                         break;
 184                                                 }
 185                                         }
 186                                 }
 187                         }
 188                         break;
 189
 190                 case VL_SLOT_LIST: {
 191                         if (vli.index == ALL_TRAINS_TRACE_RESTRICT_SLOT_ID) {
 192                                 fill_all_vehicles();
 193                         } else {
 194                                 const TraceRestrictSlot *slot = TraceRestrictSlot::GetIfValid(vli.index);
 195                                 if (slot == NULL) return false;
 196                                 for (VehicleID id : slot->occupants) {
 197                                         *list->Append() = Vehicle::Get(id);
 198                                 }
 199                         }
 200                         break;
 201                 }
 202
 203                 default: return false;
 204         }
 205
 206         list->Compact();
 207         return true;
 208 }