ground_vehicle.hpp

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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */
 
#ifndef GROUND_VEHICLE_HPP
#define GROUND_VEHICLE_HPP
 
#include "vehicle_base.h"
#include "vehicle_gui.h"
#include "landscape.h"
#include "window_func.h"
 
#include "widgets/vehicle_widget.h"
 
enum AccelStatus : uint8_t {
  AS_ACCEL, 
  AS_BRAKE, 
};
 
struct GroundVehicleCache {
  /* Cached acceleration values, recalculated when the cargo on a vehicle changes (in addition to the conditions below) */
  uint32_t cached_weight = 0; 
  uint32_t cached_slope_resistance = 0; 
  uint32_t cached_max_te = 0; 
  uint16_t cached_axle_resistance = 0; 
 
  /* Cached acceleration values, recalculated on load and each time a vehicle is added to/removed from the consist. */
  uint16_t cached_max_track_speed = 0; 
  uint32_t cached_power = 0; 
  uint32_t cached_air_drag = 0; 
 
  /* Cached NewGRF values, recalculated on load and each time a vehicle is added to/removed from the consist. */
  uint16_t cached_total_length = 0; 
  EngineID first_engine = EngineID::Invalid(); 
  uint8_t cached_veh_length = 0; 
 
  /* Cached UI information. */
  uint16_t last_speed = 0; 
 
  auto operator<=>(const GroundVehicleCache &) const = default;
};
 
enum GroundVehicleFlags : uint8_t {
  GVF_GOINGUP_BIT              = 0,  
  GVF_GOINGDOWN_BIT            = 1,  
  GVF_SUPPRESS_IMPLICIT_ORDERS = 2,  
};
 
template <class T, VehicleType Type>
struct GroundVehicle : public SpecializedVehicle<T, Type> {
  GroundVehicleCache gcache{}; 
  uint16_t gv_flags = 0; 
 
  typedef GroundVehicle<T, Type> GroundVehicleBase; 
 
  GroundVehicle(VehicleID index) : SpecializedVehicle<T, Type>(index) {}
 
  void PowerChanged();
  void CargoChanged();
  int GetAcceleration() const;
  bool IsChainInDepot() const override;
 
  uint Crash(bool flooded) override
  {
    /* 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);
    }
    return this->Vehicle::Crash(flooded);
  }
 
  inline int64_t GetSlopeResistance() const
  {
    int64_t incl = 0;
 
    for (const T *u = T::From(this); u != nullptr; u = u->Next()) {
      if (HasBit(u->gv_flags, GVF_GOINGUP_BIT)) {
        incl += u->gcache.cached_slope_resistance;
      } else if (HasBit(u->gv_flags, GVF_GOINGDOWN_BIT)) {
        incl -= u->gcache.cached_slope_resistance;
      }
    }
 
    return incl;
  }
 
  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);
 
    if (T::From(this)->TileMayHaveSlopedTrack()) {
      /* To check whether the current tile is sloped, and in which
       * direction it is sloped, we get the 'z' at the center of
       * the tile (middle_z) and the edge of the tile (old_z),
       * which we then can compare. */
      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);
      }
    }
  }
 
  inline void UpdateZPosition()
  {
#if 0
    /* The following code does this: */
 
    if (HasBit(this->gv_flags, GVF_GOINGUP_BIT)) {
      switch (this->direction) {
        case DIR_NE:
          this->z_pos += (this->x_pos & 1) ^ 1; break;
        case DIR_SW:
          this->z_pos += (this->x_pos & 1); break;
        case DIR_NW:
          this->z_pos += (this->y_pos & 1) ^ 1; break;
        case DIR_SE:
          this->z_pos += (this->y_pos & 1); break;
        default: break;
      }
    } else if (HasBit(this->gv_flags, GVF_GOINGDOWN_BIT)) {
      switch (this->direction) {
        case DIR_NE:
          this->z_pos -= (this->x_pos & 1) ^ 1; break;
        case DIR_SW:
          this->z_pos -= (this->x_pos & 1); break;
        case DIR_NW:
          this->z_pos -= (this->y_pos & 1) ^ 1; break;
        case DIR_SE:
          this->z_pos -= (this->y_pos & 1); break;
        default: break;
      }
    }
 
    /* But gcc 4.4.5 isn't able to nicely optimise it, and the resulting
     * 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.
     * 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 (T::From(this)->HasToUseGetSlopePixelZ()) {
        /* In some cases, we have to use GetSlopePixelZ() */
        this->z_pos = GetSlopePixelZ(this->x_pos, this->y_pos, true);
        return;
      }
      /* DirToDiagDir() is a simple right shift */
      DiagDirection dir = DirToDiagDir(this->direction);
      /* Read variables, so the compiler knows the access doesn't trap */
      int8_t x_pos = this->x_pos;
      int8_t y_pos = this->y_pos;
      /* DiagDirToAxis() is a simple mask */
      int8_t d = DiagDirToAxis(dir) == AXIS_X ? x_pos : y_pos;
      /* We need only the least significant bit */
      d &= 1;
      d ^= (int8_t)(dir == DIAGDIR_NW || dir == DIAGDIR_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,
       * without any shift */
      this->z_pos += HasBit(this->gv_flags, GVF_GOINGUP_BIT) ? d : -d;
    }
 
    assert(this->z_pos == GetSlopePixelZ(this->x_pos, this->y_pos, true));
  }
 
  inline int UpdateInclination(bool new_tile, bool update_delta)
  {
    int old_z = this->z_pos;
 
    if (new_tile) {
      this->UpdateZPositionAndInclination();
    } else {
      this->UpdateZPosition();
    }
 
    this->UpdateViewport(true, update_delta);
    return old_z;
  }
 
  inline void SetFrontEngine() { SetBit(this->subtype, GVSF_FRONT); }
 
  inline void ClearFrontEngine() { ClrBit(this->subtype, GVSF_FRONT); }
 
  inline void SetArticulatedPart() { SetBit(this->subtype, GVSF_ARTICULATED_PART); }
 
  inline void ClearArticulatedPart() { ClrBit(this->subtype, GVSF_ARTICULATED_PART); }
 
  inline void SetWagon() { SetBit(this->subtype, GVSF_WAGON); }
 
  inline void ClearWagon() { ClrBit(this->subtype, GVSF_WAGON); }
 
  inline void SetEngine() { SetBit(this->subtype, GVSF_ENGINE); }
 
  inline void ClearEngine() { ClrBit(this->subtype, GVSF_ENGINE); }
 
  inline void SetFreeWagon() { SetBit(this->subtype, GVSF_FREE_WAGON); }
 
  inline void ClearFreeWagon() { ClrBit(this->subtype, GVSF_FREE_WAGON); }
 
  inline void SetMultiheaded() { SetBit(this->subtype, GVSF_MULTIHEADED); }
 
  inline void ClearMultiheaded() { ClrBit(this->subtype, GVSF_MULTIHEADED); }
 
  inline bool IsFreeWagon() const { return HasBit(this->subtype, GVSF_FREE_WAGON); }
 
  inline bool IsEngine() const { return HasBit(this->subtype, GVSF_ENGINE); }
 
  inline bool IsWagon() const { return HasBit(this->subtype, GVSF_WAGON); }
 
  inline bool IsMultiheaded() const { return HasBit(this->subtype, GVSF_MULTIHEADED); }
 
  inline bool IsRearDualheaded() const { return this->IsMultiheaded() && !this->IsEngine(); }
 
  inline void SetLastSpeed()
  {
    if (this->cur_speed != this->gcache.last_speed) {
      SetWindowWidgetDirty(WC_VEHICLE_VIEW, this->index, WID_VV_START_STOP);
      this->gcache.last_speed = this->cur_speed;
    }
  }
 
protected:
  inline uint DoUpdateSpeed(uint accel, int min_speed, int max_speed)
  {
    uint spd = this->subspeed + accel;
    this->subspeed = (uint8_t)spd;
 
    /* When we are going faster than the maximum speed, reduce the speed
     * somewhat gradually. But never lower than the maximum speed. */
    int tempmax = max_speed;
    if (this->cur_speed > max_speed) {
      tempmax = std::max(this->cur_speed - (this->cur_speed / 10) - 1, max_speed);
    }
 
    /* Enforce a maximum and minimum speed. Normally we would use something like
     * Clamp for this, but in this case min_speed might be below the maximum speed
     * threshold for some reason. That makes acceleration fail and assertions
     * happen in Clamp. So make it explicit that min_speed overrules the maximum
     * speed by explicit ordering of min and max. */
    this->cur_speed = spd = std::max(std::min(this->cur_speed + ((int)spd >> 8), tempmax), min_speed);
 
    int scaled_spd = this->GetAdvanceSpeed(spd);
 
    scaled_spd += this->progress;
    this->progress = 0; // set later in *Handler or *Controller
    return scaled_spd;
  }
};
 
#endif /* GROUND_VEHICLE_HPP */