AShipPawn Class Reference

#include <ShipPawn.h>

Inheritance diagram for AShipPawn:

Public Member Functions
	AShipPawn ()
virtual ETeamAttitude::Type	GetTeamAttitudeTowards (const AActor &Other) const override
virtual void	SetGenericTeamId (const FGenericTeamId &NewTeamID) override
virtual FGenericTeamId	GetGenericTeamId () const override
bool	GetIsPiloted () const
int32	GetPassengers () const
Public Member Functions inherited from AInteractablePawn
	AInteractablePawn ()
virtual void	ReceiveStartFocus (AActor *Caller)
virtual void	ReceiveEndFocus (AActor *Caller)
virtual void	ReceiveOnInteract (AActor *Caller, const EInteractionType InteractionType)
virtual void	ReceiveOnEndInteract (AActor *Caller)
virtual void	ReceiveOnOverlap (AActor *Caller)
virtual void	ReceiveOnEndOverlap (AActor *Caller)
virtual void	ReceiveToggleSwitch (AActor *Caller, const bool bOn)
virtual void	InteractionDataUpdated ()
virtual void	SetupPlayerInputComponent (class UInputComponent *PlayerInputComponent) override
Public Member Functions inherited from ICharacterInterface
virtual USkeletalMeshComponent *	GetCharacterSecondaryMesh () const
virtual void	StartThreatIndication (AActor *PawnThreat)
virtual void	UpdateThreatIndication (const FVector &Location, const float DetectionAmount)
virtual void	StopThreatIndication ()

Protected Member Functions
virtual void	BeginPlay () override
virtual void	PossessedBy (AController *NewController) override
virtual void	OnInteract (AActor *Caller, const int32 SelectedInteraction) override
virtual void	PilotShip (AActor *Caller)
virtual void	EnterShip (AActor *Caller)
virtual void	SetCallerInShip (AActor *Caller, AAIController *AIController)
void	OnPilotEntered (AActor *NewPilot)
void	OnPilotExited (AActor *NewPilot)
virtual void	PilotExitShip ()
virtual void	PilotEnterShip ()
void	OnPassengerEntered (AActor *NewPassenger)
void	OnPassengerExited (AActor *NewPassenger)
virtual void	PassengerEnterShip (const int32 NewPassenger)
virtual void	PassengerExitShip (const int32 ExitPassenger)
void	OpenDoor ()
void	CloseDoor ()
void	OnOpenDoor ()
void	OnCloseDoor ()
int32	GetTeamID () const
virtual ECharacterType	GetCharacterType () const override
virtual EFactionType	GetCharacterFaction () const override
virtual bool	GetIsDead () const override
virtual void	SetCharacterVehicleMode (const EVehicleMode Mode) override
virtual void	PointDamageTaken (AActor *DamagedActor, float Damage, class AController *InstigatedBy, FVector HitLocation, class UPrimitiveComponent *HitComponent, FName BoneName, FVector ShotFromDirection, const class UDamageType *DamageType, AActor *DamageCauser)
virtual void	OnDeath (AActor *OwningActor, EDeathType DeathType, AActor *DeathCauser, AController *DeathInstigator)
Protected Member Functions inherited from AInteractablePawn
virtual bool	SaveGame () override
virtual bool	LoadGame () override
FVector	GetCustomInteractionLocation () const
void	LogDebugError (const FString &Message) const
void	LogDebugError (const FString &Message, const int32 Value) const
void	LogDebugError (const FString &Message, const float Value) const
void	LogDebugWarning (const FString &Message) const
void	LogDebugWarning (const FString &Message, const int32 Value) const
void	LogDebugWarning (const FString &Message, const float Value) const
void	LogDebugMessage (const FString &Message, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const int32 Value, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const float Value, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const bool bValue, const bool bWarning, const bool bError) const
void	LogOnScreenMessage (const int32 Key, const FString &Message, FColor Color=FColor::Green) const
void	SetCategoryName (const FLogCategoryBase &Category)

Protected Attributes
FGenericTeamId	TeamID
ECharacterType	CharacterType = ECharacterType::Defence
EFactionType	OwnerFaction = EFactionType::Alliance
bool	bDead = false
bool	bOpenDoor = false
UCapsuleComponent *	CapsuleComponent
UStaticMeshComponent *	MeshComponent
USpringArmComponent *	SpringArm
UCameraComponent *	CameraComponent
USceneComponent *	ExitLocation
USceneComponent *	PilotLocation
UCharacterHealthComponent *	HealthComponent
float	ExplosionDamage = 500000.0f
bool	bCanAIPilot = false
bool	bAttachWhenEnter = false
bool	bStopAILogicWhenEnter = false
AActor *	Pilot = nullptr
TArray< AActor * >	Passengers
int32	MaxPassengers = 3
Protected Attributes inherited from AInteractablePawn
class UAudioReactionComponent *	AudioReactionComponent
class UInteractableActorComponent *	InteractableActorComponent
class UAIPerceptionStimuliSourceComponent *	PerceptionStimuliComponent
bool	bDebuggingMode = false

Constructor & Destructor Documentation

AShipPawn()

AShipPawn::AShipPawn

(

)

{
    InteractionData.InteractionTypes.Add(FInteractionType(EInteractionType::Pilot));
    InteractionData.InteractionTypes.Add(FInteractionType(EInteractionType::Enter));
    InteractionData.InteractionTypes.Add(FInteractionType(EInteractionType::Exit));
    InteractionData.InteractionTypes.Add(FInteractionType(EInteractionType::Open));
    InteractionData.InteractionTypes.Add(FInteractionType(EInteractionType::Close));
 
 
    
    CapsuleComponent = CreateDefaultSubobject<UCapsuleComponent>(TEXT("Capsule"));
    RootComponent = CapsuleComponent;
    CapsuleComponent->InitCapsuleSize(140.0f, 155.0f);
    MeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    MeshComponent->SetRelativeRotation(FRotator(0.0f,-90.0f,0.0f));
    MeshComponent->SetupAttachment(RootComponent);
    SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("Spring Arm"));
    SpringArm->TargetArmLength = 750.0f;
    //? @TODO Temp for Demo Ship    
    SpringArm->bUsePawnControlRotation = true;
    SpringArm->TargetOffset = FVector(0.0f,0.0f,200.0f);
    SpringArm->SetupAttachment(MeshComponent);
    CameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
    CameraComponent->SetupAttachment(SpringArm);
 
    ExitLocation = CreateDefaultSubobject<USceneComponent>(TEXT("Exit Location"));
    ExitLocation->SetupAttachment(MeshComponent);
    PilotLocation = CreateDefaultSubobject<USceneComponent>(TEXT("Pilot Location"));
    PilotLocation->SetupAttachment(MeshComponent);
 
    HealthComponent = CreateDefaultSubobject<UCharacterHealthComponent>(TEXT("Health Component"));
    HealthComponent->bHasShield = false;
 
    AIControllerClass = nullptr;
    AutoPossessAI = EAutoPossessAI::Disabled;
}

Member Function Documentation

BeginPlay()

void AShipPawn::BeginPlay ( )

overrideprotectedvirtual

Reimplemented from AInteractablePawn.

{
    Super::BeginPlay();
    SetGenericTeamId(FGenericTeamId(UAIBPLib::GetTeamIDFromFaction(OwnerFaction)));
    if(HealthComponent != nullptr)
    {
        HealthComponent->OnDeath.AddUniqueDynamic(this, &AShipPawn::OnDeath);
    }
    OnTakePointDamage.AddUniqueDynamic(this, &AShipPawn::PointDamageTaken);
    if(Passengers.Num() >= MaxPassengers)
    {
        InteractionData.SetInteractionHidden(EInteractionType::Enter, true);
    }
    InteractionData.SetInteractionHidden(EInteractionType::Exit, true);
    if(bOpenDoor)
    {
        InteractionData.SetInteractionHidden(EInteractionType::Open, true);
    }
    else
    {
        InteractionData.SetInteractionHidden(EInteractionType::Close, true);
    }
}

CloseDoor()

void AShipPawn::CloseDoor ( )

protected

{
    if(bOpenDoor == false){return;}
    bOpenDoor = false;
    InteractionData.SetInteractionHidden(EInteractionType::Close, true);
    InteractionData.SetInteractionHidden(EInteractionType::Open, false);
    OnCloseDoor();
}

EnterShip()

void AShipPawn::EnterShip ( AActor * Caller )

protectedvirtual

{
    if(Passengers.Num() >= MaxPassengers)
    {
        return;
    }
    const int32 NewPassenger = Passengers.AddUnique(Caller);
    AAIController* AIController = Cast<AAIController>(Caller->GetInstigatorController());
    SetCallerInShip(Caller, AIController);
    //@TODO don't disable input //
    APlayerController* PlayerController = Cast<APlayerController>(Caller->GetInstigatorController());
    if(PlayerController != nullptr)
    {
        // PlayerController->DisableInput(PlayerController);
    }
    PassengerEnterShip(NewPassenger);
}

GetCharacterFaction()

virtual EFactionType AShipPawn::GetCharacterFaction ( ) const

inlineoverrideprotectedvirtual

Implements ICharacterInterface.

{return OwnerFaction;};

GetCharacterType()

virtual ECharacterType AShipPawn::GetCharacterType ( ) const

inlineoverrideprotectedvirtual

Implements ICharacterInterface.

{return CharacterType;};

GetGenericTeamId()

virtual FGenericTeamId AShipPawn::GetGenericTeamId ( ) const

inlineoverridevirtual

{return TeamID;};

GetIsDead()

virtual bool AShipPawn::GetIsDead ( ) const

inlineoverrideprotectedvirtual

Implements ICharacterInterface.

{return bDead;};

GetIsPiloted()

bool AShipPawn::GetIsPiloted ( ) const

inline

{return Pilot != nullptr;};

GetPassengers()

int32 AShipPawn::GetPassengers ( ) const

inline

{return Passengers.Num();};

GetTeamAttitudeTowards()

ETeamAttitude::Type AShipPawn::GetTeamAttitudeTowards ( const AActor & Other ) const

overridevirtual

{
    if(const APawn* OtherPawn = Cast<APawn>(&Other))
    {
        const IGenericTeamAgentInterface* TeamAgent = Cast<IGenericTeamAgentInterface>(OtherPawn);
        if(TeamAgent == nullptr){TeamAgent = Cast<IGenericTeamAgentInterface>(OtherPawn->GetController());}
        if(TeamAgent !=  nullptr)
        {
            const FGenericTeamId OtherTeamID = TeamAgent->GetGenericTeamId();
            const EFactionType OtherPawnFaction = UAIBPLib::GetFactionFromTeamID(OtherTeamID);
            bool bSuccess = false;
            const FFactionRelationship Relationship = UAIBPLib::GetFactionRelationship(this, OwnerFaction, OtherPawnFaction, bSuccess);
            if(bSuccess)
            {
                switch (Relationship.RelationshipStatus)
                {
                case ERelationshipStatus::Friendly:
                case ERelationshipStatus::Allied:
                    return ETeamAttitude::Friendly;
                case ERelationshipStatus::Default:
                case ERelationshipStatus::Neutral:
                case ERelationshipStatus::UnFriendly:
                    return ETeamAttitude::Neutral;
                case ERelationshipStatus::Hostile:
                case ERelationshipStatus::Enemy:
                    return ETeamAttitude::Hostile;
                }
            }
        }
    }
    return ETeamAttitude::Neutral;  
}

GetTeamID()

int32 AShipPawn::GetTeamID ( ) const

inlineprotected

{return (TeamID == FGenericTeamId::NoTeam) ? INDEX_NONE : (int32)TeamID;};

OnCloseDoor()

void AShipPawn::OnCloseDoor ( )

protected

OnDeath()

void AShipPawn::OnDeath ( AActor * OwningActor, EDeathType DeathType, AActor * DeathCauser, AController * DeathInstigator )

protectedvirtual

{
    bDead = true;
    AActor* PreviousPilot = Pilot;
    PilotExitShip();
    UGameplayStatics::ApplyDamage(PreviousPilot, ExplosionDamage, DeathInstigator, DeathCauser, UExplosionDamage::StaticClass());
}

OnInteract()

void AShipPawn::OnInteract ( AActor * Caller, const int32 SelectedInteraction )

overrideprotectedvirtual

{
    Super::OnInteract(Caller, SelectedInteraction);
    if(Caller == nullptr || Caller->GetInstigatorController() == nullptr){return;}
    FInteractionType InteractionType;
    if(UBaseHelpersBPLib::GetInteraction(InteractionType, InteractionData, SelectedInteraction) == false){return;}
    
    if(InteractionType.InteractionType == EInteractionType::Pilot)
    {
        PilotShip(Caller);
        CloseDoor();
    }
    
    if(InteractionType.InteractionType == EInteractionType::Enter)
    {
        EnterShip(Caller);
    }
    if(InteractionType.InteractionType == EInteractionType::Exit)
    {
        if(Passengers.Contains(Caller))
        {
            PassengerExitShip(Passengers.IndexOfByKey(Caller));
        }
        if(GetIsPiloted())
        {
            PilotExitShip();
            OpenDoor();
        }
    }
    if(InteractionType.InteractionType == EInteractionType::Open)
    {
        OpenDoor();
    }
    if(InteractionType.InteractionType == EInteractionType::Close)
    {
        CloseDoor();
    }
 
    if(Passengers.Num() >= MaxPassengers)
    {
        InteractionData.SetInteractionHidden(EInteractionType::Enter, true);
    }
    else
    {
        InteractionData.SetInteractionHidden(EInteractionType::Enter, false);
    }
    if(GetIsPiloted())
    {
        InteractionData.SetInteractionHidden(EInteractionType::Pilot, true);
        InteractionData.SetInteractionHidden(EInteractionType::Exit, false);
    }
    else
    {
        InteractionData.SetInteractionHidden(EInteractionType::Pilot, false);
    }
    const IBaseInterface* BaseCaller = Cast<IBaseInterface>(Caller);
    if(BaseCaller != nullptr)
    {
        BaseCaller->InteractionDataUpdated();
    }
 
 
    // if(PlayerController != nullptr)
    // {
    //  if(Pilot == nullptr)
    //  {
    //      Pilot = Caller;
    //      PlayerController->Possess(this);
    //      PilotEnterShip();
    //      OnPilotEntered(Pilot);
    //  }
    //  else
    //  {
    //      // if(Passengers.Num() >= MaxPassengers)
    //      // {
    //      //  InteractionData.SetInteractionHidden(EInteractionType::Enter, true);
    //      //  InteractionData.SetInteractionHidden(EInteractionType::Open, false);
    //      //  // InteractionData.bShowDefault = true;
    //      //  // InteractionData.DefaultInteraction = InteractionData.InteractionTypes.Add(FInteractionType(EInteractionType::Open));
    //      //  return;
    //      // }
    //      if(Passengers.Num() >= MaxPassengers)
    //      {
    //          return;
    //      }
    //      Passengers.Add(Caller);
    //      PlayerController->DisableInput(PlayerController);
    //  }
    //  Caller->SetActorEnableCollision(false);
    //  if(bAttachWhenEnter)
    //  {
    //      const FAttachmentTransformRules TransformRules = FAttachmentTransformRules(EAttachmentRule::SnapToTarget, false);
    //      Caller->AttachToComponent(PilotLocation, TransformRules);
    //  }
    // }
    // else
    // {
    //  // const AAIController* AIController = Cast<AAIController>(Caller->GetInstigatorController());
    //  if(AIController != nullptr)
    //  {
    //      if(bCanAIPilot && Pilot == nullptr)
    //      {
    //          Pilot = Caller;
    //          PilotEnterShip();
    //          OnPilotEntered(Pilot);
    //      }
    //      else
    //      {
    //          if(Passengers.Num() >= MaxPassengers)
    //          {
    //              return;
    //          }
    //          Passengers.Add(Caller);
    //          // if(Passengers.Num() >= MaxPassengers)
    //          // {
    //          //  InteractionData.SetInteractionHidden(EInteractionType::Enter, true);
    //          //  InteractionData.SetInteractionHidden(EInteractionType::Open, false);
    //          //  // InteractionData.bShowDefault = true;
    //          //  // InteractionData.DefaultInteraction = InteractionData.InteractionTypes.Add(FInteractionType(EInteractionType::Open));
    //          // }
    //
    //      }
    //      Caller->SetActorEnableCollision(false);
    //      if(bAttachWhenEnter)
    //      {
    //          const FAttachmentTransformRules TransformRules = FAttachmentTransformRules(EAttachmentRule::SnapToTarget, false);
    //          Caller->AttachToComponent(PilotLocation, TransformRules);
    //      }
    //      if(AIController->GetBrainComponent() != nullptr)
    //      {
    //          AIController->GetBrainComponent()->StopLogic("Escape");
    //      }
    //  }
    // }
}

OnOpenDoor()

void AShipPawn::OnOpenDoor ( )

protected

OnPassengerEntered()

void AShipPawn::OnPassengerEntered ( AActor * NewPassenger )

protected

OnPassengerExited()

void AShipPawn::OnPassengerExited ( AActor * NewPassenger )

protected

OnPilotEntered()

void AShipPawn::OnPilotEntered ( AActor * NewPilot )

protected

OnPilotExited()

void AShipPawn::OnPilotExited ( AActor * NewPilot )

protected

OpenDoor()

void AShipPawn::OpenDoor ( )

protected

{
    if(bOpenDoor){return;}
 
    bOpenDoor = true;
    InteractionData.SetInteractionHidden(EInteractionType::Close, false);
    InteractionData.SetInteractionHidden(EInteractionType::Open, true);
    OnOpenDoor();
}

PassengerEnterShip()

void AShipPawn::PassengerEnterShip ( const int32 NewPassenger )

protectedvirtual

{
    if(Passengers.IsValidIndex(NewPassenger) == false || PilotLocation == nullptr){return;}
    APawn* PassengerPawn = Cast<APawn>(Passengers[NewPassenger]);
    if(PassengerPawn == nullptr){UE_LOG(LogCustomCharacters, Error, TEXT("Passenger not a Pawn of sHip ?? "))return;}
    PassengerPawn->GetMovementComponent()->StopMovementImmediately();
    PassengerPawn->SetActorLocation(PilotLocation->GetComponentLocation());
    PassengerPawn->SetActorRotation(PilotLocation->GetComponentRotation());
    PassengerPawn->SetActorHiddenInGame(true);
    //@TODO Temp Mode
    ICharacterInterface* Character = Cast<ICharacterInterface>(PassengerPawn);
    if(Character != nullptr)
    {
        Character->SetCharacterVehicleMode(EVehicleMode::Passenger);
    }
    OnPassengerEntered(PassengerPawn);
}

PassengerExitShip()

void AShipPawn::PassengerExitShip ( const int32 ExitPassenger )

protectedvirtual

{
    if(Passengers.IsValidIndex(ExitPassenger) == false || ExitLocation == nullptr){return;}
    APawn* PassengerPawn = Cast<APawn>(Passengers[ExitPassenger]);
    if(PassengerPawn == nullptr){UE_LOG(LogCustomCharacters, Error, TEXT("PassengerPawn not a Pawn of sHip ?? "))return;}
    PassengerPawn->SetActorEnableCollision(true);
    PassengerPawn->SetActorLocation(ExitLocation->GetComponentLocation());
    PassengerPawn->SetActorRotation(ExitLocation->GetComponentRotation());
    APlayerController* PlayerController = Cast<APlayerController>(GetController());
    if(PlayerController != nullptr)
    {
        PlayerController->EnableInput(PlayerController);
    }
    const AAIController* AIController = Cast<AAIController>(GetController());
    if(bStopAILogicWhenEnter && AIController != nullptr && AIController->GetBrainComponent() != nullptr)
    {
        AIController->GetBrainComponent()->RestartLogic();
    }
    PassengerPawn->SetActorHiddenInGame(false);
    //@TODO Temp Mode
    ICharacterInterface* Character = Cast<ICharacterInterface>(PassengerPawn);
    if(Character != nullptr)
    {
        Character->SetCharacterVehicleMode(EVehicleMode::None);
    }
    OnPassengerExited(PassengerPawn);
    Passengers.RemoveAt(ExitPassenger);
}

PilotEnterShip()

void AShipPawn::PilotEnterShip ( )

protectedvirtual

{
    if(GetIsPiloted() == false || PilotLocation == nullptr){return;}
    APawn* PilotPawn = Cast<APawn>(Pilot);
    if(PilotPawn == nullptr){UE_LOG(LogCustomCharacters, Error, TEXT("Pilot not a Pawn of sHip ?? "))return;}
    PilotPawn->GetMovementComponent()->StopMovementImmediately();
    PilotPawn->SetActorLocation(PilotLocation->GetComponentLocation());
    PilotPawn->SetActorRotation(PilotLocation->GetComponentRotation());
    PilotPawn->SetActorHiddenInGame(true);
    InteractionData.SetInteractionHidden(EInteractionType::Pilot, true);
    //@TODO Temp Mode
    ICharacterInterface* Character = Cast<ICharacterInterface>(PilotPawn);
    if(Character != nullptr)
    {
        Character->SetCharacterVehicleMode(EVehicleMode::Driver);
    }
}

PilotExitShip()

void AShipPawn::PilotExitShip ( )

protectedvirtual

{
    if(GetIsPiloted() == false || ExitLocation == nullptr){return;}
    APawn* PilotPawn = Cast<APawn>(Pilot);
    if(PilotPawn == nullptr){UE_LOG(LogCustomCharacters, Error, TEXT("Pilot not a Pawn of sHip ?? "))return;}
    PilotPawn->SetActorEnableCollision(true);
    APlayerController* PlayerController = Cast<APlayerController>(GetController());
    if(PlayerController != nullptr)
    {
        PlayerController->Possess(PilotPawn);
    }
    
    PilotPawn->SetActorLocation(ExitLocation->GetComponentLocation());
    PilotPawn->SetActorRotation(ExitLocation->GetComponentRotation());
    const AAIController* AIController = Cast<AAIController>(GetController());
    if(bStopAILogicWhenEnter && AIController != nullptr && AIController->GetBrainComponent() != nullptr)
    {
        AIController->GetBrainComponent()->RestartLogic();
    }
    PilotPawn->SetActorHiddenInGame(false);
    InteractionData.SetInteractionHidden(EInteractionType::Pilot, false);
    //@TODO Temp Mode
    ICharacterInterface* Character = Cast<ICharacterInterface>(PilotPawn);
    if(Character != nullptr)
    {
        Character->SetCharacterVehicleMode(EVehicleMode::None);
    }
    OnPilotExited(Pilot);
    Pilot = nullptr;
}

PilotShip()

void AShipPawn::PilotShip ( AActor * Caller )

protectedvirtual

{
    AController* CallerController = Cast<AController>(Caller->GetInstigatorController());
    bool bPlayer = true;
    AAIController* AIController = Cast<AAIController>(Caller->GetInstigatorController());
    if(AIController != nullptr)
    {
        bPlayer = false;
        if(bCanAIPilot == false){EnterShip(Caller);return;}
    }
    if(CallerController != nullptr && Pilot == nullptr)
    {
        Pilot = Caller;
        SetCallerInShip(Caller, AIController);
        if(bPlayer)
        {
            CallerController->Possess(this);
        }
        PilotEnterShip();
        OnPilotEntered(Pilot);
    }
}

PointDamageTaken()

void AShipPawn::PointDamageTaken ( AActor * DamagedActor, float Damage, class AController * InstigatedBy, FVector HitLocation, class UPrimitiveComponent * HitComponent, FName BoneName, FVector ShotFromDirection, const class UDamageType * DamageType, AActor * DamageCauser )

protectedvirtual

{
    if(InstigatedBy != nullptr && InstigatedBy->GetPawn() != nullptr)
    {
        bool bKillingHit = false;
        if(HealthComponent != nullptr)
        {
            bKillingHit = HealthComponent->GetHealth() <= 0.0f;
        }
        IHitMarkerInterface* HitMarkerActor = Cast<IHitMarkerInterface>(InstigatedBy->GetPawn());
        if(HitMarkerActor != nullptr)
        {
            HitMarkerActor->HitMarker(this, Damage, DamageType, BoneName, HitLocation, bKillingHit);
        }
    }
}

PossessedBy()

void AShipPawn::PossessedBy ( AController * NewController )

overrideprotectedvirtual

{
    Super::PossessedBy(NewController);
    if(NewController == nullptr){return;}
    const IGenericTeamAgentInterface* TeamOwner = Cast<IGenericTeamAgentInterface>(NewController);
    if(TeamOwner == nullptr){return;}
    SetGenericTeamId(TeamOwner->GetGenericTeamId());
    OwnerFaction = UAIBPLib::GetFactionFromTeamID(GetGenericTeamId());
    if(HealthComponent != nullptr)
    {
        const APlayerController* PlayerController = Cast<APlayerController>(NewController);
        if(PlayerController != nullptr && PlayerController->GetHUD() != nullptr)
        {
            HealthComponent->SetupComponent(nullptr, nullptr, NewController, Cast<AActor>(PlayerController->GetHUD()), false, bDead);
        }
    }
    if(bDebuggingMode){const FString FactionName = UEnum::GetValueAsString(OwnerFaction);UE_LOG(LogCustomCharacters, Warning, TEXT("Owner Faction SET %s"), *FactionName);}
}

SetCallerInShip()

void AShipPawn::SetCallerInShip ( AActor * Caller, AAIController * AIController )

protectedvirtual

{
    Caller->SetActorEnableCollision(false);
    if(bAttachWhenEnter)
    {
        const FAttachmentTransformRules TransformRules = FAttachmentTransformRules(EAttachmentRule::SnapToTarget, false);
        Caller->AttachToComponent(PilotLocation, TransformRules);
    }
    if(bStopAILogicWhenEnter && AIController != nullptr && AIController->GetBrainComponent() != nullptr)
    {
        AIController->GetBrainComponent()->StopLogic("Pilot");
    }
}

SetCharacterVehicleMode()

virtual void AShipPawn::SetCharacterVehicleMode ( const EVehicleMode Mode )

inlineoverrideprotectedvirtual

Implements ICharacterInterface.

{return;};

SetGenericTeamId()

void AShipPawn::SetGenericTeamId ( const FGenericTeamId & NewTeamID )

overridevirtual

{
    if(HasAuthority())
    {
        const FGenericTeamId OldTeamID = TeamID;
 
        // MARK_PROPERTY_DIRTY_FROM_NAME(ThisClass, MyTeamID, this);
        TeamID = NewTeamID;
        if(bDebuggingMode){ UE_LOG(LogCustomCharacters, Error, TEXT("team %i"), NewTeamID.GetId());}
 
        // ConditionalBroadcastTeamChanged(this, OldTeamID, NewTeamID);
    }
    else
    {
        if(bDebuggingMode){UE_LOG(LogTemp, Error, TEXT("Cannot set team for %s on non-authority"), *GetPathName(this));}
    }
}

Member Data Documentation

bAttachWhenEnter

bool AShipPawn::bAttachWhenEnter = false

protected

bCanAIPilot

bool AShipPawn::bCanAIPilot = false

protected

bDead

bool AShipPawn::bDead = false

protected

bOpenDoor

bool AShipPawn::bOpenDoor = false

protected

bStopAILogicWhenEnter

bool AShipPawn::bStopAILogicWhenEnter = false

protected

CameraComponent

UCameraComponent* AShipPawn::CameraComponent

protected

CapsuleComponent

UCapsuleComponent* AShipPawn::CapsuleComponent

protected

CharacterType

ECharacterType AShipPawn::CharacterType = ECharacterType::Defence

protected

ExitLocation

USceneComponent* AShipPawn::ExitLocation

protected

ExplosionDamage

float AShipPawn::ExplosionDamage = 500000.0f

protected

HealthComponent

UCharacterHealthComponent* AShipPawn::HealthComponent

protected

MaxPassengers

int32 AShipPawn::MaxPassengers = 3

protected

Not Including Pilot

MeshComponent

UStaticMeshComponent* AShipPawn::MeshComponent

protected

OwnerFaction

EFactionType AShipPawn::OwnerFaction = EFactionType::Alliance

protected

Passengers

TArray<AActor*> AShipPawn::Passengers

protected

Pilot

AActor* AShipPawn::Pilot = nullptr

protected

PilotLocation

USceneComponent* AShipPawn::PilotLocation

protected

SpringArm

USpringArmComponent* AShipPawn::SpringArm

protected

TeamID

FGenericTeamId AShipPawn::TeamID

protected

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/CustomALS/Source/CustomALS/Public/Pawns/ShipPawn.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/CustomALS/Source/CustomALS/Private/Pawns/ShipPawn.cpp