GameMode游戏模式

#include <GameFramework/SpringArmComponent.h>
class UCameraComponent;

protected:
	UPROPERTY(VisibleAnywhere)
	USpringArmComponent* SpringArmComponent;

	UPROPERTY(VisibleAnywhere)
	UCameraComponent* CameraComponent;

#include "Camera/CameraComponent.h"
APlayerCharacter::APlayerCharacter()
{
	PrimaryActorTick.bCanEverTick = false;

	/* camera boom */ 
	SpringArmComponent = CreateDefaultSubobject<USpringArmComponent>("SpringArmComponent");
	SpringArmComponent->SetupAttachment(RootComponent);
	SpringArmComponent->TargetArmLength = 180.0f;
	SpringArmComponent->bUsePawnControlRotation = true;

	/* camera */
	CameraComponent = CreateDefaultSubobject<UCameraComponent>("CameraComponent");
	CameraComponent->SetupAttachment(SpringArmComponent, USpringArmComponent::SocketName);
	CameraComponent->bUsePawnControlRotation = false;
}

#include "InputActionValue.h"
protected:
	void Move(const FInputActionValue& Value);
	void Look(const FInputActionValue& Value);

private:
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Enhanced Input", meta = (AllowPrivateAccess = "true"))
	class UInputMappingContext* DefaultMappingContext;
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Enhanced Input", meta = (AllowPrivateAccess = "true"))
	class UInputAction* MoveAction;
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Enhanced Input", meta = (AllowPrivateAccess = "true"))
	class UInputAction* LookAction;

#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h"
void APlayerCharacter::BeginPlay()
{
	Super::BeginPlay();
	if (const ULocalPlayer* Player = (GEngine && GetWorld()) ? GEngine->GetFirstGamePlayer(GetWorld()) : nullptr) 
    {
		UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(Player);
		if (DefaultMappingContext) 
        {
			Subsystem->AddMappingContext(DefaultMappingContext, 0);
		}
	}
}

void APlayerCharacter::Move(const FInputActionValue& Value)
{
	FVector2D MoveVector = Value.Get<FVector2D>();
	if (Controller) 
    {
		// 获取控制器的旋转角度
		const FRotator Rotation = Controller->GetControlRotation();
		// 提取Yaw 水平旋转角度
		const FRotator YawRotation(0, Rotation.Yaw, 0);
		// 根据旋转角度计算前进方向
		// FRotationMatrix(YawRotation) 会生成一个旋转矩阵，表示角色的旋转状态
		// 通过 GetUnitAxis(EAxis::X)，我们从矩阵中获取角色在水平方向上的前进方向（即角色面朝的方向）
		const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
		// 根据旋转角度计算右侧方向
		const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
		// 将输入的 X 值映射到角色的前进方向
		AddMovementInput(ForwardDirection, MoveVector.X);
		// 将输入的 Y 值映射到角色的右侧方向
		AddMovementInput(RightDirection, MoveVector.Y);
	}
}

void APlayerCharacter::Look(const FInputActionValue& Value)
{
	// 角色看向 视角旋转
	FVector2D LookVector = Value.Get<FVector2D>();
	if (Controller) 
    {
		AddControllerYawInput(-LookVector.X);
		AddControllerPitchInput(LookVector.Y);
	}
}

void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);

	// 确保输入组件是增强输入组件 绑定InputAction
	if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent)) {
		EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &APlayerCharacter::Look);
		EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &APlayerCharacter::Move);
		EnhancedInputComponent->BindAction(FireAction, ETriggerEvent::Triggered, this, &APlayerCharacter::Fire);
	}
}

UCLASS()
class FPSCPP_API UPlayerAnimInstance : public UAnimInstance
{
	GENERATED_BODY()

	/* UAnimInstance类的虚函数 生命周期初始化 和 每一帧调用 */
	virtual void NativeInitializeAnimation() override;
	virtual void NativeUpdateAnimation(float DeltaTime) override;
	
	UPROPERTY(BlueprintReadOnly, Category = "Character", meta = (AllowPrivateAccess = "true"))
	class APlayerCharacter* PlayerCharacter;

	UPROPERTY(BlueprintReadOnly, Category = "Movement", meta = (AllowPrivateAccess = "true"))
	float Speed;
};

#include "PlayerCharacter.h"
#include "GameFramework/CharacterMovementComponent.h"

void UPlayerAnimInstance::NativeInitializeAnimation()
{
	Super::NativeInitializeAnimation();

	PlayerCharacter = Cast<APlayerCharacter>(TryGetPawnOwner());
}

void UPlayerAnimInstance::NativeUpdateAnimation(float DeltaTime)
{
	Super::NativeUpdateAnimation(DeltaTime);
	
	if (PlayerCharacter == nullptr) return;
    // 得到角色的速度 设置z方向速度为0 因为不需要
	FVector Velocity = PlayerCharacter->GetVelocity();
	Velocity.Z = 0.f;
	Speed = Velocity.Size();
}

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Combat")
	class USoundCue* FireSoundEffect;

#include "Sound/SoundCue.h"
void APlayerCharacter::Fire(const FInputActionValue& Value)
{
	/* 开火声音 */ 
	if (FireSoundEffect) 
    {
		UGameplayStatics::PlaySound2D(this, FireSoundEffect);
	}
}

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Combat")
	class UParticleSystem* MuzzleFlash;

#include "Kismet/GameplayStatics.h"
#include "Particles/ParticleSystem.h"
#include "Engine/SkeletalMeshSocket.h"
/* 获取开火枪口socket */ 
	const USkeletalMeshSocket* GunBarrelSocket = GetMesh()->GetSocketByName("GunBarrelSocket");
    if (GunBarrelSocket) 
    {
        const FTransform SocketTransform = GunBarrelSocket->GetSocketTransform(GetMesh());
        /* 开火粒子特效 */ 
        if (MuzzleFlash) {
            UGameplayStatics::SpawnEmitterAtLocation(GetWorld(), MuzzleFlash, SocketTransform);
        }
    }

#include "DrawDebugHelpers.h"
	/* LineTrace Hit */
	// 存储碰撞结果
	FHitResult HitRst;
	// 开火位置为射线起始位置
	const FVector Start{ SocketTransform.GetLocation() };
	// 获取枪口的朝向 和 子弹发射的方向
	const FQuat StartRotation{ SocketTransform.GetRotation() };
	const FVector RotationAxis{ StartRotation.GetAxisX()};
	// 确认射线的终点位置
	const FVector End{ Start + RotationAxis * 500000.f };
	// 碰撞结果 射线起始位置 射线终点位置 碰撞通道射线检测
	GetWorld()->LineTraceSingleByChannel(HitRst, Start, End, ECollisionChannel::ECC_Visibility);

	// 如果碰撞就发出一条描绘出来的射线
	if (HitRst.bBlockingHit)
	{
		DrawDebugLine(GetWorld(), Start, End, FColor::Red, 0, 2);
		DrawDebugSphere(GetWorld(), HitRst.Location, 10, 10, FColor::Blue, 0, 2);
	}

	/* Impact Effect */ 
	if (HitRst.bBlockingHit)
	{
		if (ImpactEffect) 
		{
			UGameplayStatics::SpawnEmitterAtLocation(GetWorld(), ImpactEffect, HitRst.Location);
		}
	}

	/* 子弹发射轨迹 */
	if (BeamParticles) 
	{
		FVector BeamEndPoint{ FVector::ZeroVector };

		if (HitRst.bBlockingHit)
		{
			BeamEndPoint = HitRst.Location;
		}

		UParticleSystemComponent* Beam = UGameplayStatics::SpawnEmitterAtLocation(GetWorld(), BeamParticles, SocketTransform);
		if (Beam) 
		{
			UE_LOG(LogTemp, Warning, TEXT("Beam->SetVectorParameter()"));
			Beam->SetVectorParameter(FName("Target"), BeamEndPoint);
		}

	}

    // 获取枪口位置（起点）
    FVector Start = SocketTransform.GetLocation();
    // 获取玩家控制器
    APlayerController* PlayerController = GetWorld()->GetFirstPlayerController();
    if (PlayerController)
    {
        // 获取屏幕中心准星位置
        FVector2D ScreenCenter = FVector2D(GEngine->GameViewport->Viewport->GetSizeXY()) / 2;
		// StartWorld 是由 DeprojectScreenPositionToWorld 函数赋值的
        // 将屏幕空间中的位置（例如屏幕中心）转换为世界空间中的位置
        FVector StartWorld, Direction;
        // 将屏幕中心位置转换为世界空间中的位置和方向
        if (PlayerController->DeprojectScreenPositionToWorld(ScreenCenter.X, ScreenCenter.Y, StartWorld, Direction))
        {
            FVector End = StartWorld + Direction * 10000.0f;
            FHitResult HitRst;
            GetWorld()->LineTraceSingleByChannel(HitRst, Start, End, ECollisionChannel::ECC_Visibility);
        }
    }

	// .h中
	UFUNCTION(BlueprintCallable, Category = "Cube")
	void Shrink();

	UFUNCTION(BlueprintCallable, Category = "Cube")
	void DestoryCube();

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shooting")
	bool bHasBeenShotOnce = false;
	// cpp中
    void ACubeBeShot::Shrink()
    {
        FVector CurrentScale = GetActorScale3D();
        SetActorScale3D(CurrentScale * 0.5f);
    }

    void ACubeBeShot::DestoryCube()
    {
        Destroy();
    }

UPROPERTY(EditAnywhere, meta = (BindWidget))
class UTextBlock* TextScore;

// 获取当前分数并返回文本
UFUNCTION(BlueprintCallable, Category = "UI")
FText GetScoreText() const;

FText UPlayerUserWidget::GetScoreText() const
{
    APlayerCharacter* Player = Cast<APlayerCharacter>(UGameplayStatics::GetPlayerCharacter(GetWorld(), 0));

    if (Player)
    {
        return FText::AsNumber(Player->GetScore());
    }

    // 如果没有获取到玩家角色，返回 0
    return FText::AsNumber(0);
}

protected:
	float ShootCooldown = 0.2f;
	float LastShootTime;
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Score")
    int32 AmountScore;

    // 指向 ScoreWidget 的类引用
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UI")
    TSubclassOf<UPlayerUserWidget> UserWidgetClass;
    // 增加分数的方法
    UFUNCTION(BlueprintCallable, Category = "Score")
    void AddScore(int32 Score);

    // 获取分数的 getter 方法
    UFUNCTION(BlueprintCallable, Category = "Score")
    int32 GetScore() const;  // 返回分数
    UPlayerUserWidget* ScoreWidget;

// 设置开火间隔 避免连续射击方块直接销毁
float CurrentTime = GetWorld()->GetTimeSeconds();
if(CurrentTime - LastShootTime < ShootCooldown) {
        return;
}
LastShootTime = CurrentTime;

	AActor* HitActor = HitRst.GetActor();
    // 如果射线碰撞到物体
    if (HitRst.bBlockingHit && HitActor->IsA(ACubeBeShot::StaticClass()))
    {
        ACubeBeShot* Cube = Cast<ACubeBeShot>(HitActor);
        UE_LOG(LogTemp, Log, TEXT("Cube hit, bHasBeenShotOnce: %s"), Cube->bHasBeenShotOnce ? TEXT("True") : TEXT("False"));
        if (Cube)
        {
            // 判断是否是第一次射击
            if (!Cube->bHasBeenShotOnce)
            {
                // 第一次射击：缩小
                Cube->Shrink();
                // 标记被射击了一次
                Cube->bHasBeenShotOnce = true;
            }
            else
            {
                // 第二次射击：销毁
                // 随机生成 10 或 20 分
                int32 RandomScore = FMath::RandBool() ? 10 : 20;;
                AddScore(RandomScore);
                Cube->DestoryCube();

            }
        }
    }

if (UserWidgetClass)
{
    ScoreWidget = CreateWidget<UPlayerUserWidget>(GetWorld(), UserWidgetClass);
    if (ScoreWidget) {
        ScoreWidget->AddToViewport();
    }
}

void APlayerCharacter::AddScore(int32 Score)
{
    AmountScore += Score;
}
int32 APlayerCharacter::GetScore() const
{
    return AmountScore;
}