vehiclelist.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#include "stdafx.h"
#include "train.h"
#include "vehicle_func.h"
#include "vehiclelist.h"
#include "vehiclelist_func.h"
#include "group.h"
 
#include "safeguards.h"
 
uint32_t VehicleListIdentifier::Pack() const
{
  uint8_t c = this->company == OWNER_NONE ? 0xF : (uint8_t)this->company;
  assert(c             < (1 <<  4));
  assert(this->vtype   < (1 <<  2));
  assert(this->index   < (1 << 20));
  assert(this->type    < VLT_END);
  static_assert(VLT_END <= (1 <<  3));
 
  return c << 28 | this->type << 23 | this->vtype << 26 | this->index;
}
 
bool VehicleListIdentifier::UnpackIfValid(uint32_t data)
{
  uint8_t c        = GB(data, 28, 4);
  this->company = c == 0xF ? OWNER_NONE : (CompanyID)c;
  this->type    = (VehicleListType)GB(data, 23, 3);
  this->vtype   = (VehicleType)GB(data, 26, 2);
  this->index   = GB(data, 0, 20);
 
  return this->type < VLT_END;
}
 
/* static */ VehicleListIdentifier VehicleListIdentifier::UnPack(uint32_t data)
{
  VehicleListIdentifier result;
  [[maybe_unused]] bool ret = result.UnpackIfValid(data);
  assert(ret);
  return result;
}
 
struct BuildDepotVehicleListData
{
  VehicleList *engines; 
  VehicleList *wagons; 
  VehicleType type; 
  bool individual_wagons; 
};
 
static Vehicle *BuildDepotVehicleListProc(Vehicle *v, void *data)
{
  auto bdvld = static_cast<BuildDepotVehicleListData *>(data);
  if (v->type != bdvld->type || !v->IsInDepot()) return nullptr;
 
  if (bdvld->type == VEH_TRAIN) {
    const Train *t = Train::From(v);
    if (t->IsArticulatedPart() || t->IsRearDualheaded()) return nullptr;
    if (bdvld->wagons != nullptr && t->First()->IsFreeWagon()) {
      if (bdvld->individual_wagons || t->IsFreeWagon()) bdvld->wagons->push_back(t);
      return nullptr;
    }
  }
 
  if (v->IsPrimaryVehicle()) bdvld->engines->push_back(v);
  return nullptr;
};
 
void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)
{
  engines->clear();
  if (wagons != nullptr && wagons != engines) wagons->clear();
 
  BuildDepotVehicleListData bdvld{engines, wagons, type, individual_wagons};
  FindVehicleOnPos(tile, &bdvld, BuildDepotVehicleListProc);
}
 
bool GenerateVehicleSortList(VehicleList *list, const VehicleListIdentifier &vli)
{
  list->clear();
 
  switch (vli.type) {
    case VL_STATION_LIST:
      FindVehiclesWithOrder(
        [&vli](const Vehicle *v) { return v->type == vli.vtype; },
        [&vli](const Order *order) { return (order->IsType(OT_GOTO_STATION) || order->IsType(OT_GOTO_WAYPOINT) || order->IsType(OT_IMPLICIT)) && order->GetDestination() == vli.index; },
        [&list](const Vehicle *v) { list->push_back(v); }
      );
      break;
 
    case VL_SHARED_ORDERS: {
      /* Add all vehicles from this vehicle's shared order list */
      const Vehicle *v = Vehicle::GetIfValid(vli.index);
      if (v == nullptr || v->type != vli.vtype || !v->IsPrimaryVehicle()) return false;
 
      for (; v != nullptr; v = v->NextShared()) {
        list->push_back(v);
      }
      break;
    }
 
    case VL_GROUP_LIST:
      if (vli.index != ALL_GROUP) {
        for (const Vehicle *v : Vehicle::Iterate()) {
          if (v->type == vli.vtype && v->IsPrimaryVehicle() &&
              v->owner == vli.company && GroupIsInGroup(v->group_id, vli.index)) {
            list->push_back(v);
          }
        }
        break;
      }
      [[fallthrough]];
 
    case VL_STANDARD:
      for (const Vehicle *v : Vehicle::Iterate()) {
        if (v->type == vli.vtype && v->owner == vli.company && v->IsPrimaryVehicle()) {
          list->push_back(v);
        }
      }
      break;
 
    case VL_DEPOT_LIST:
      FindVehiclesWithOrder(
        [&vli](const Vehicle *v) { return v->type == vli.vtype; },
        [&vli](const Order *order) { return order->IsType(OT_GOTO_DEPOT) && !(order->GetDepotActionType() & ODATFB_NEAREST_DEPOT) && order->GetDestination() == vli.index; },
        [&list](const Vehicle *v) { list->push_back(v); }
      );
      break;
 
    default: return false;
  }
 
  return true;
}