WheeledVehicleAIController.cpp

Go to the documentation of this file.

// Copyright (c) 2026 Computer Vision Center (CVC) at the Universitat Autonoma
// de Barcelona (UAB).
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "Carla/Vehicle/WheeledVehicleAIController.h"
#include "Carla.h"
#include "Carla/MapGen/RoadMap.h"
#include "Carla/Traffic/RoutePlanner.h"
#include "Carla/Vehicle/CarlaWheeledVehicle.h"
#include "Carla/CityMapGenerator.h"
#include "Carla/Util/RandomEngine.h"
 
#include <util/ue-header-guard-begin.h>
#include "EngineUtils.h"
#include "GameFramework/Pawn.h"
#include "ChaosWheeledVehicleMovementComponent.h"
#include <util/ue-header-guard-end.h>
 
// =============================================================================
// -- Static local methods -----------------------------------------------------
// =============================================================================
 
static bool RayCast(const AActor &Actor, const FVector &Start, const FVector &End)
{
  FHitResult OutHit;
  static FName TraceTag = FName(TEXT("VehicleTrace"));
  FCollisionQueryParams CollisionParams(TraceTag, true);
  CollisionParams.AddIgnoredActor(&Actor);
 
  const bool Success = Actor.GetWorld()->LineTraceSingleByObjectType(
      OutHit,
      Start,
      End,
      FCollisionObjectQueryParams(FCollisionObjectQueryParams::AllDynamicObjects),
      CollisionParams);
 
  // DrawDebugLine(Actor.GetWorld(), Start, End,
  //     Success ? FColor(255, 0, 0) : FColor(0, 255, 0), false);
 
  return Success && OutHit.bBlockingHit;
}
 
static bool IsThereAnObstacleAhead(
    const ACarlaWheeledVehicle &Vehicle,
    const float Speed,
    const FVector &Direction)
{
  const auto ForwardVector = Vehicle.GetVehicleOrientation();
  const auto VehicleBounds = Vehicle.GetVehicleBoundingBoxExtent();
 
  FVector NormDirection = Direction.GetSafeNormal();
 
  const float Distance = std::max(50.0f, Speed * Speed); // why?
 
  const FVector StartCenter = Vehicle.GetActorLocation() +
      (ForwardVector * (250.0f + VehicleBounds.X / 2.0f)) + FVector(0.0f, 0.0f, 50.0f);
  const FVector EndCenter = StartCenter + NormDirection * (Distance + VehicleBounds.X / 2.0f);
 
  const FVector StartRight = StartCenter +
      (FVector(ForwardVector.Y, -ForwardVector.X, ForwardVector.Z) * 100.0f);
  const FVector EndRight = StartRight + NormDirection * (Distance + VehicleBounds.X / 2.0f);
 
  const FVector StartLeft = StartCenter +
      (FVector(-ForwardVector.Y, ForwardVector.X, ForwardVector.Z) * 100.0f);
  const FVector EndLeft = StartLeft + NormDirection * (Distance + VehicleBounds.X / 2.0f);
 
  return
    RayCast(Vehicle, StartCenter, EndCenter) ||
    RayCast(Vehicle, StartRight, EndRight) ||
    RayCast(Vehicle, StartLeft, EndLeft);
}
 
template <typename T>
static void ClearQueue(std::queue<T> &Queue)
{
  std::queue<T> EmptyQueue;
  Queue.swap(EmptyQueue);
}
 
// =============================================================================
// -- Constructor and destructor -----------------------------------------------
// =============================================================================
 
AWheeledVehicleAIController::AWheeledVehicleAIController(const FObjectInitializer &ObjectInitializer)
  : Super(ObjectInitializer)
{
  RandomEngine = CreateDefaultSubobject<URandomEngine>(TEXT("RandomEngine"));
 
  RandomEngine->Seed(RandomEngine->GenerateRandomSeed());
 
  PrimaryActorTick.bCanEverTick = true;
  PrimaryActorTick.TickGroup = TG_PrePhysics;
}
 
AWheeledVehicleAIController::~AWheeledVehicleAIController() {}
 
// =============================================================================
// -- AController --------------------------------------------------------------
// =============================================================================
 
void AWheeledVehicleAIController::OnPossess(APawn *aPawn)
{
  Super::OnPossess(aPawn);
 
  if (IsPossessingAVehicle())
  {
    UE_LOG(LogCarla, Error, TEXT("Controller already possessing a vehicle!"));
    return;
  }
  Vehicle = Cast<ACarlaWheeledVehicle>(aPawn);
  check(Vehicle != nullptr);
  MaximumSteerAngle = Vehicle->GetMaximumSteerAngle();
  if (MaximumSteerAngle <= 0.0f) {
    UE_LOG(LogCarla, Error, TEXT("MaximumSteerAngle > 0.0f")); 
  }
 
  ConfigureAutopilot(bAutopilotEnabled);
 
  if (RoadMap == nullptr)
  {
    TActorIterator<ACityMapGenerator> It(GetWorld());
    RoadMap = (It ? It->GetRoadMap() : nullptr);
  }
}
 
void AWheeledVehicleAIController::OnUnPossess()
{
  Super::OnUnPossess();
 
  Vehicle = nullptr;
}
 
void AWheeledVehicleAIController::Tick(const float DeltaTime)
{
  TRACE_CPUPROFILER_EVENT_SCOPE(AWheeledVehicleAIController::Tick);
  Super::Tick(DeltaTime);
 
  if (!IsPossessingAVehicle())
  {
    return;
  }
 
  if (!bAutopilotEnabled && !bControlIsSticky)
  {
    Vehicle->ApplyVehicleControl(FVehicleControl{}, EVehicleInputPriority::Relaxation);
  }
 
  Vehicle->FlushVehicleControl();
}
 
// =============================================================================
// -- Autopilot ----------------------------------------------------------------
// =============================================================================
 
void AWheeledVehicleAIController::ConfigureAutopilot(const bool Enable, const bool KeepState)
{
  bAutopilotEnabled = Enable;
  if (!KeepState)
  {
    // Reset state.
    Vehicle->SetSteeringInput(0.0f);
    Vehicle->SetThrottleInput(0.0f);
    Vehicle->SetBrakeInput(0.0f);
    Vehicle->SetReverse(false);
    Vehicle->SetHandbrakeInput(false);
    ClearQueue(TargetLocations);
    Vehicle->SetAIVehicleState(
        bAutopilotEnabled ?
        ECarlaWheeledVehicleState::FreeDriving :
        ECarlaWheeledVehicleState::AutopilotOff);
  }
 
  TrafficLightState = ETrafficLightState::Green;
}
 
// =============================================================================
// -- Traffic ------------------------------------------------------------------
// =============================================================================
 
void AWheeledVehicleAIController::SetFixedRoute(
    const TArray<FVector> &Locations,
    const bool bOverwriteCurrent)
{
  if (bOverwriteCurrent)
  {
    ClearQueue(TargetLocations);
  }
  for (auto &Location : Locations)
  {
    TargetLocations.emplace(Location);
  }
}