From a57eb70e05ffee43f9a856773bb601ba91a07c0b Mon Sep 17 00:00:00 2001 From: Peter Nelson Date: Sun, 21 Jun 2026 08:50:45 +0100 Subject: [PATCH] Codechange: make GroundVehicleFlag(s) a scoped enum/EnumBitSet (#15754) --- src/ground_vehicle.hpp | 35 ++++++++++++-------------------- src/order_cmd.cpp | 6 ++---- src/roadveh.h | 2 +- src/roadveh_cmd.cpp | 2 +- src/saveload/afterload.cpp | 14 ++++++------- src/train_cmd.cpp | 41 +++++++++++++------------------------- src/tunnelbridge_cmd.cpp | 6 +++--- src/vehicle.cpp | 21 +++++++++---------- src/vehicle_base.h | 4 ++-- src/vehicle_type.h | 10 ++++++++++ 10 files changed, 61 insertions(+), 80 deletions(-) diff --git a/src/ground_vehicle.hpp b/src/ground_vehicle.hpp index 7e0f003eed..d2374df0a2 100644 --- a/src/ground_vehicle.hpp +++ b/src/ground_vehicle.hpp @@ -50,13 +50,6 @@ struct GroundVehicleCache { auto operator<=>(const GroundVehicleCache &) const = default; }; -/** Ground vehicle flags. */ -enum GroundVehicleFlags : uint8_t { - GVF_GOINGUP_BIT = 0, ///< Vehicle is currently going uphill. (Cached track information for acceleration) - GVF_GOINGDOWN_BIT = 1, ///< Vehicle is currently going downhill. (Cached track information for acceleration) - GVF_SUPPRESS_IMPLICIT_ORDERS = 2, ///< Disable insertion and removal of automatic orders until the vehicle completes the real order. -}; - /** * Base class for all vehicles that move through ground. * @@ -81,7 +74,7 @@ enum GroundVehicleFlags : uint8_t { template struct GroundVehicle : public SpecializedVehicle { GroundVehicleCache gcache{}; ///< Cache of often calculated values. - uint16_t gv_flags = 0; ///< @see GroundVehicleFlags. + GroundVehicleFlags gv_flags{}; ///< @see GroundVehicleFlags. typedef GroundVehicle GroundVehicleBase; ///< Our type @@ -105,8 +98,7 @@ struct GroundVehicle : public SpecializedVehicle { { /* Crashed vehicles aren't going up or down */ for (T *v = T::From(this); v != nullptr; v = v->Next()) { - ClrBit(v->gv_flags, GVF_GOINGUP_BIT); - ClrBit(v->gv_flags, GVF_GOINGDOWN_BIT); + v->gv_flags.Reset({GroundVehicleFlag::GoingUp, GroundVehicleFlag::GoingDown}); } return this->Vehicle::Crash(flooded); } @@ -120,9 +112,9 @@ struct GroundVehicle : public SpecializedVehicle { int64_t incl = 0; for (const T *u = T::From(this); u != nullptr; u = u->Next()) { - if (HasBit(u->gv_flags, GVF_GOINGUP_BIT)) { + if (u->gv_flags.Test(GroundVehicleFlag::GoingUp)) { incl += u->gcache.cached_slope_resistance; - } else if (HasBit(u->gv_flags, GVF_GOINGDOWN_BIT)) { + } else if (u->gv_flags.Test(GroundVehicleFlag::GoingDown)) { incl -= u->gcache.cached_slope_resistance; } } @@ -139,8 +131,7 @@ struct GroundVehicle : public SpecializedVehicle { inline void UpdateZPositionAndInclination() { this->z_pos = GetSlopePixelZ(this->x_pos, this->y_pos, true); - ClrBit(this->gv_flags, GVF_GOINGUP_BIT); - ClrBit(this->gv_flags, GVF_GOINGDOWN_BIT); + this->gv_flags.Reset({GroundVehicleFlag::GoingUp, GroundVehicleFlag::GoingDown}); if (T::From(this)->TileMayHaveSlopedTrack()) { /* To check whether the current tile is sloped, and in which @@ -150,7 +141,7 @@ struct GroundVehicle : public SpecializedVehicle { int middle_z = GetSlopePixelZ((this->x_pos & ~TILE_UNIT_MASK) | (TILE_SIZE / 2), (this->y_pos & ~TILE_UNIT_MASK) | (TILE_SIZE / 2), true); if (middle_z != this->z_pos) { - SetBit(this->gv_flags, (middle_z > this->z_pos) ? GVF_GOINGUP_BIT : GVF_GOINGDOWN_BIT); + this->gv_flags.Set((middle_z > this->z_pos) ? GroundVehicleFlag::GoingUp : GroundVehicleFlag::GoingDown); } } } @@ -166,7 +157,7 @@ struct GroundVehicle : public SpecializedVehicle { #if 0 /* The following code does this: */ - if (HasBit(this->gv_flags, GVF_GOINGUP_BIT)) { + if (this->gv_flags.Test(GroundVehicleFlag::GoingUp)) { switch (this->GetMovingDirection()) { case Direction::NE: this->z_pos += (this->x_pos & 1) ^ 1; break; @@ -178,7 +169,7 @@ struct GroundVehicle : public SpecializedVehicle { this->z_pos += (this->y_pos & 1); break; default: break; } - } else if (HasBit(this->gv_flags, GVF_GOINGDOWN_BIT)) { + } else if (this->gv_flags.Test(GroundVehicleFlag::GoingDown)) { switch (this->GetMovingDirection()) { case Direction::NE: this->z_pos -= (this->x_pos & 1) ^ 1; break; @@ -196,12 +187,12 @@ struct GroundVehicle : public SpecializedVehicle { * code is full of conditional jumps. */ #endif - /* Vehicle's Z position can change only if it has GVF_GOINGUP_BIT or GVF_GOINGDOWN_BIT set. + /* Vehicle's Z position can change only if it has GroundVehicleFlag::GoingUp or GroundVehicleFlag::GoingDown set. * Furthermore, if this function is called once every time the vehicle's position changes, * we know the Z position changes by +/-1 at certain moments - when x_pos, y_pos is odd/even, * depending on orientation of the slope and vehicle's direction */ - if (HasBit(this->gv_flags, GVF_GOINGUP_BIT) || HasBit(this->gv_flags, GVF_GOINGDOWN_BIT)) { + if (this->gv_flags.Any({GroundVehicleFlag::GoingUp, GroundVehicleFlag::GoingDown})) { if (T::From(this)->HasToUseGetSlopePixelZ()) { /* In some cases, we have to use GetSlopePixelZ() */ this->z_pos = GetSlopePixelZ(this->x_pos, this->y_pos, true); @@ -217,10 +208,10 @@ struct GroundVehicle : public SpecializedVehicle { /* We need only the least significant bit */ d &= 1; d ^= (int8_t)(dir == DiagDirection::NW || dir == DiagDirection::NE); - /* Subtraction instead of addition because we are testing for GVF_GOINGUP_BIT. - * GVF_GOINGUP_BIT is used because it's bit 0, so simple AND can be used, + /* Subtraction instead of addition because we are testing for GroundVehicleFlag::GoingUp. + * GroundVehicleFlag::GoingUp is used because it's bit 0, so simple AND can be used, * without any shift */ - this->z_pos += HasBit(this->gv_flags, GVF_GOINGUP_BIT) ? d : -d; + this->z_pos += this->gv_flags.Test(GroundVehicleFlag::GoingUp) ? d : -d; } assert(this->z_pos == GetSlopePixelZ(this->x_pos, this->y_pos, true)); diff --git a/src/order_cmd.cpp b/src/order_cmd.cpp index dfd54a4cde..97e0f6703a 100644 --- a/src/order_cmd.cpp +++ b/src/order_cmd.cpp @@ -877,8 +877,7 @@ void InsertOrder(Vehicle *v, Order &&new_o, VehicleOrderID sel_ord) /* We are inserting an order just before the current implicit order. * We do not know whether we will reach current implicit or the newly inserted order first. * So, disable creation of implicit orders until we are on track again. */ - uint16_t &gv_flags = u->GetGroundVehicleFlags(); - SetBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS); + u->GetGroundVehicleFlags().Set(GroundVehicleFlag::SuppressImplicitOrders); } if (sel_ord <= u->cur_implicit_order_index) { uint cur = u->cur_implicit_order_index + 1; @@ -2051,8 +2050,7 @@ bool UpdateOrderDest(Vehicle *v, const Order *order, int conditional_depth, bool /* Disable creation of implicit orders. * When inserting them we do not know that we would have to make the conditional orders point to them. */ if (v->IsGroundVehicle()) { - uint16_t &gv_flags = v->GetGroundVehicleFlags(); - SetBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS); + v->GetGroundVehicleFlags().Set(GroundVehicleFlag::SuppressImplicitOrders); } } else { UpdateVehicleTimetable(v, true); diff --git a/src/roadveh.h b/src/roadveh.h index 1872213f50..fc188f8d06 100644 --- a/src/roadveh.h +++ b/src/roadveh.h @@ -305,7 +305,7 @@ protected: // These functions should not be called outside acceleration code. const RoadVehicle *rv = this->First(); /* Check if this vehicle is in the same direction as the road under. - * We already know it has either GVF_GOINGUP_BIT or GVF_GOINGDOWN_BIT set. */ + * We already know it has either GroundVehicleFlag::GoingUp or GroundVehicleFlag::GoingDown set. */ if (rv->state <= RVSB_TRACKDIR_MASK && IsReversingRoadTrackdir(static_cast(rv->state))) { /* If the first vehicle is reversing, this vehicle may be reversing too diff --git a/src/roadveh_cmd.cpp b/src/roadveh_cmd.cpp index 4d565425e1..3fa4ca7148 100644 --- a/src/roadveh_cmd.cpp +++ b/src/roadveh_cmd.cpp @@ -1700,7 +1700,7 @@ static void CheckIfRoadVehNeedsService(RoadVehicle *v) return; } - SetBit(v->gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS); + v->gv_flags.Set(GroundVehicleFlag::SuppressImplicitOrders); v->current_order.MakeGoToDepot(depot, OrderDepotTypeFlag::Service); v->SetDestTile(rfdd.tile); SetWindowWidgetDirty(WindowClass::VehicleView, v->index, WID_VV_START_STOP); diff --git a/src/saveload/afterload.cpp b/src/saveload/afterload.cpp index 0702b8ad69..4863b7594c 100644 --- a/src/saveload/afterload.cpp +++ b/src/saveload/afterload.cpp @@ -474,7 +474,7 @@ static void FixOwnerOfRailTrack(Tile t) * @param dir vehicle's direction, or # Direction::Invalid if it can be ignored * @return inclination bits to set */ -static uint FixVehicleInclination(Vehicle *v, Direction dir) +static GroundVehicleFlags FixVehicleInclination(Vehicle *v, Direction dir) { /* Compute place where this vehicle entered the tile */ int entry_x = v->x_pos; @@ -495,13 +495,13 @@ static uint FixVehicleInclination(Vehicle *v, Direction dir) uint8_t middle_z = GetSlopePixelZ(middle_x, middle_y, true); /* middle_z == entry_z, no height change. */ - if (middle_z == entry_z) return 0; + if (middle_z == entry_z) return {}; /* middle_z < entry_z, we are going downwards. */ - if (middle_z < entry_z) return 1U << GVF_GOINGDOWN_BIT; + if (middle_z < entry_z) return GroundVehicleFlag::GoingDown; /* middle_z > entry_z, we are going upwards. */ - return 1U << GVF_GOINGUP_BIT; + return GroundVehicleFlag::GoingUp; } /** @@ -2750,8 +2750,7 @@ bool AfterLoadGame() t->flags.Reset(VehicleRailFlag{2}); /* Clear both bits first. */ - ClrBit(t->gv_flags, GVF_GOINGUP_BIT); - ClrBit(t->gv_flags, GVF_GOINGDOWN_BIT); + t->gv_flags.Reset({GroundVehicleFlag::GoingUp, GroundVehicleFlag::GoingDown}); /* Crashed vehicles can't be going up/down. */ if (t->vehstatus.Test(VehState::Crashed)) break; @@ -2764,8 +2763,7 @@ bool AfterLoadGame() } case VehicleType::Road: { RoadVehicle *rv = RoadVehicle::From(v); - ClrBit(rv->gv_flags, GVF_GOINGUP_BIT); - ClrBit(rv->gv_flags, GVF_GOINGDOWN_BIT); + rv->gv_flags.Reset({GroundVehicleFlag::GoingUp, GroundVehicleFlag::GoingDown}); /* Crashed vehicles can't be going up/down. */ if (rv->vehstatus.Test(VehState::Crashed)) break; diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp index 7e35f9a732..6960fe636a 100644 --- a/src/train_cmd.cpp +++ b/src/train_cmd.cpp @@ -1613,32 +1613,20 @@ static void MarkTrainAsStuck(Train *consist) /** * Swap the two up/down flags in two ways: * - Swap values of \a swap_flag1 and \a swap_flag2, and - * - If going up previously (#GVF_GOINGUP_BIT set), the #GVF_GOINGDOWN_BIT is set, and vice versa. + * - If going up previously (#GroundVehicleFlag::GoingUp set), the #GroundVehicleFlag::GoingDown is set, and vice versa. * @param[in,out] swap_flag1 First train flag. * @param[in,out] swap_flag2 Second train flag. */ -static void SwapTrainFlags(uint16_t *swap_flag1, uint16_t *swap_flag2) +static void SwapTrainFlags(GroundVehicleFlags *swap_flag1, GroundVehicleFlags *swap_flag2) { - uint16_t flag1 = *swap_flag1; - uint16_t flag2 = *swap_flag2; - - /* Clear the flags */ - ClrBit(*swap_flag1, GVF_GOINGUP_BIT); - ClrBit(*swap_flag1, GVF_GOINGDOWN_BIT); - ClrBit(*swap_flag2, GVF_GOINGUP_BIT); - ClrBit(*swap_flag2, GVF_GOINGDOWN_BIT); + GroundVehicleFlags flag1 = *swap_flag1; + GroundVehicleFlags flag2 = *swap_flag2; /* Reverse the rail-flags (if needed) */ - if (HasBit(flag1, GVF_GOINGUP_BIT)) { - SetBit(*swap_flag2, GVF_GOINGDOWN_BIT); - } else if (HasBit(flag1, GVF_GOINGDOWN_BIT)) { - SetBit(*swap_flag2, GVF_GOINGUP_BIT); - } - if (HasBit(flag2, GVF_GOINGUP_BIT)) { - SetBit(*swap_flag1, GVF_GOINGDOWN_BIT); - } else if (HasBit(flag2, GVF_GOINGDOWN_BIT)) { - SetBit(*swap_flag1, GVF_GOINGUP_BIT); - } + swap_flag2->Set(GroundVehicleFlag::GoingDown, flag1.Test(GroundVehicleFlag::GoingUp)); + swap_flag2->Set(GroundVehicleFlag::GoingUp, flag1.Test(GroundVehicleFlag::GoingDown)); + swap_flag1->Set(GroundVehicleFlag::GoingDown, flag2.Test(GroundVehicleFlag::GoingUp)); + swap_flag1->Set(GroundVehicleFlag::GoingUp, flag2.Test(GroundVehicleFlag::GoingDown)); } /** @@ -1710,7 +1698,7 @@ static void ReverseTrainSwapVeh(Train *v, int l, int r) SwapTrainFlags(&a->gv_flags, &b->gv_flags); } else { - /* Swap GVF_GOINGUP_BIT/GVF_GOINGDOWN_BIT. + /* Swap GroundVehicleFlag::GoingUp/GroundVehicleFlag::GoingDown. * This is a little bit redundant way, a->gv_flags will * be (re)set twice, but it reduces code duplication */ SwapTrainFlags(&a->gv_flags, &a->gv_flags); @@ -2051,9 +2039,8 @@ static void ReverseTrainDirection(Train *consist) for (Train *u = consist; u != nullptr; u = u->Next()) { /* Invert going up/down */ - if (HasBit(u->gv_flags, GVF_GOINGUP_BIT) || HasBit(u->gv_flags, GVF_GOINGDOWN_BIT)) { - ToggleBit(u->gv_flags, GVF_GOINGDOWN_BIT); - ToggleBit(u->gv_flags, GVF_GOINGUP_BIT); + if (u->gv_flags.Any({GroundVehicleFlag::GoingUp, GroundVehicleFlag::GoingDown})) { + u->gv_flags.Flip({GroundVehicleFlag::GoingUp, GroundVehicleFlag::GoingDown}); } UpdateStatusAfterSwap(u, false); } @@ -2698,7 +2685,7 @@ public: old_dest_tile(_v->dest_tile), old_last_station_visited(_v->last_station_visited), index(_v->cur_real_order_index), - suppress_implicit_orders(HasBit(_v->gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS)), + suppress_implicit_orders(_v->gv_flags.Test(GroundVehicleFlag::SuppressImplicitOrders)), restored(false) { } @@ -2711,7 +2698,7 @@ public: this->v->current_order = this->old_order; this->v->dest_tile = this->old_dest_tile; this->v->last_station_visited = this->old_last_station_visited; - AssignBit(this->v->gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS, suppress_implicit_orders); + this->v->gv_flags.Set(GroundVehicleFlag::SuppressImplicitOrders, suppress_implicit_orders); this->restored = true; } @@ -4245,7 +4232,7 @@ static void CheckIfTrainNeedsService(Train *v) return; } - SetBit(v->gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS); + v->gv_flags.Set(GroundVehicleFlag::SuppressImplicitOrders); v->current_order.MakeGoToDepot(depot, OrderDepotTypeFlag::Service, OrderNonStopFlag::NonStop, OrderDepotActionFlag::NearestDepot); v->dest_tile = tfdd.tile; SetWindowWidgetDirty(WindowClass::VehicleView, v->index, WID_VV_START_STOP); diff --git a/src/tunnelbridge_cmd.cpp b/src/tunnelbridge_cmd.cpp index ba66786c1e..996a5be0a5 100644 --- a/src/tunnelbridge_cmd.cpp +++ b/src/tunnelbridge_cmd.cpp @@ -1930,11 +1930,11 @@ static void ChangeTileOwner_TunnelBridge(TileIndex tile, Owner old_owner, Owner template static void PrepareToEnterBridge(T *gv) { - if (HasBit(gv->gv_flags, GVF_GOINGUP_BIT)) { + if (gv->gv_flags.Test(GroundVehicleFlag::GoingUp)) { gv->z_pos++; - ClrBit(gv->gv_flags, GVF_GOINGUP_BIT); + gv->gv_flags.Reset(GroundVehicleFlag::GoingUp); } else { - ClrBit(gv->gv_flags, GVF_GOINGDOWN_BIT); + gv->gv_flags.Reset(GroundVehicleFlag::GoingDown); } } diff --git a/src/vehicle.cpp b/src/vehicle.cpp index 4ecd5cccae..c1d0d214ee 100644 --- a/src/vehicle.cpp +++ b/src/vehicle.cpp @@ -2189,10 +2189,10 @@ PaletteID GetVehiclePalette(const Vehicle *v) void Vehicle::DeleteUnreachedImplicitOrders() { if (this->IsGroundVehicle()) { - uint16_t &gv_flags = this->GetGroundVehicleFlags(); - if (HasBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS)) { + GroundVehicleFlags &gv_flags = this->GetGroundVehicleFlags(); + if (gv_flags.Test(GroundVehicleFlag::SuppressImplicitOrders)) { /* Do not delete orders, only skip them */ - ClrBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS); + gv_flags.Reset(GroundVehicleFlag::SuppressImplicitOrders); this->cur_implicit_order_index = this->cur_real_order_index; InvalidateVehicleOrder(this, 0); return; @@ -2253,7 +2253,7 @@ void Vehicle::BeginLoading() if (this->IsGroundVehicle() && (in_list == nullptr || !in_list->IsType(OT_IMPLICIT) || in_list->GetDestination() != this->last_station_visited)) { - bool suppress_implicit_orders = HasBit(this->GetGroundVehicleFlags(), GVF_SUPPRESS_IMPLICIT_ORDERS); + bool suppress_implicit_orders = this->GetGroundVehicleFlags().Test(GroundVehicleFlag::SuppressImplicitOrders); /* Do not create consecutive duplicates of implicit orders */ const Order *prev_order = this->cur_implicit_order_index > 0 ? this->GetOrder(this->cur_implicit_order_index - 1) : (this->GetNumOrders() > 1 ? this->GetLastOrder() : nullptr); if (prev_order == nullptr || @@ -2320,8 +2320,7 @@ void Vehicle::BeginLoading() /* InsertOrder disabled creation of implicit orders for all vehicles with the same implicit order. * Reenable it for this vehicle */ - uint16_t &gv_flags = this->GetGroundVehicleFlags(); - ClrBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS); + this->GetGroundVehicleFlags().Reset(GroundVehicleFlag::SuppressImplicitOrders); } } } @@ -2631,8 +2630,7 @@ CommandCost Vehicle::SendToDepot(DoCommandFlags flags, DepotCommandFlags command if (this->current_order.GetDepotOrderType().Test(OrderDepotTypeFlag::PartOfOrders)) this->IncrementRealOrderIndex(); if (this->IsGroundVehicle()) { - uint16_t &gv_flags = this->GetGroundVehicleFlags(); - SetBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS); + this->GetGroundVehicleFlags().Set(GroundVehicleFlag::SuppressImplicitOrders); } this->current_order.MakeDummy(); @@ -2649,8 +2647,7 @@ CommandCost Vehicle::SendToDepot(DoCommandFlags flags, DepotCommandFlags command if (this->current_order.IsType(OT_LOADING)) this->LeaveStation(); if (this->IsGroundVehicle() && this->GetNumManualOrders() > 0) { - uint16_t &gv_flags = this->GetGroundVehicleFlags(); - SetBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS); + this->GetGroundVehicleFlags().Set(GroundVehicleFlag::SuppressImplicitOrders); } this->SetDestTile(closest_depot.location); @@ -3238,7 +3235,7 @@ const GroundVehicleCache *Vehicle::GetGroundVehicleCache() const * @pre The vehicle is a #GroundVehicle. * @return #GroundVehicleFlags of the vehicle. */ -uint16_t &Vehicle::GetGroundVehicleFlags() +GroundVehicleFlags &Vehicle::GetGroundVehicleFlags() { assert(this->IsGroundVehicle()); if (this->type == VehicleType::Train) { @@ -3253,7 +3250,7 @@ uint16_t &Vehicle::GetGroundVehicleFlags() * @pre The vehicle is a #GroundVehicle. * @return #GroundVehicleFlags of the vehicle. */ -const uint16_t &Vehicle::GetGroundVehicleFlags() const +const GroundVehicleFlags &Vehicle::GetGroundVehicleFlags() const { assert(this->IsGroundVehicle()); if (this->type == VehicleType::Train) { diff --git a/src/vehicle_base.h b/src/vehicle_base.h index 4d4f8173e3..c6a7785edf 100644 --- a/src/vehicle_base.h +++ b/src/vehicle_base.h @@ -337,8 +337,8 @@ public: GroundVehicleCache *GetGroundVehicleCache(); const GroundVehicleCache *GetGroundVehicleCache() const; - uint16_t &GetGroundVehicleFlags(); - const uint16_t &GetGroundVehicleFlags() const; + GroundVehicleFlags &GetGroundVehicleFlags(); + const GroundVehicleFlags &GetGroundVehicleFlags() const; void DeleteUnreachedImplicitOrders(); diff --git a/src/vehicle_type.h b/src/vehicle_type.h index f70896a2ae..f5b3d3b585 100644 --- a/src/vehicle_type.h +++ b/src/vehicle_type.h @@ -102,4 +102,14 @@ using VehicleRandomTriggers = EnumBitSet; template using VehicleTypeIndexArray = EnumIndexArray; +/** Ground vehicle flags. */ +enum class GroundVehicleFlag : uint8_t { + GoingUp = 0, ///< Vehicle is currently going uphill. (Cached track information for acceleration) + GoingDown = 1, ///< Vehicle is currently going downhill. (Cached track information for acceleration) + SuppressImplicitOrders = 2, ///< Disable insertion and removal of automatic orders until the vehicle completes the real order. +}; + +/** Bitset of \c GroundVehicleFlag elements. */ +using GroundVehicleFlags = EnumBitSet; + #endif /* VEHICLE_TYPE_H */