463 lines
12 KiB
C++
463 lines
12 KiB
C++
// Fill out your copyright notice in the Description page of Project Settings.
|
|
|
|
|
|
#include "CombatComponent.h"
|
|
|
|
#include "Blaster/Character/BlasterCharacter.h"
|
|
#include "Blaster/PlayerController/BlasterPlayerController.h"
|
|
#include "Blaster/Weapon/Weapon.h"
|
|
#include "Camera/CameraComponent.h"
|
|
#include "Engine/SkeletalMeshSocket.h"
|
|
#include "GameFramework/CharacterMovementComponent.h"
|
|
#include "Kismet/GameplayStatics.h"
|
|
#include "Net/UnrealNetwork.h"
|
|
|
|
UCombatComponent::UCombatComponent()
|
|
{
|
|
PrimaryComponentTick.bCanEverTick = true;
|
|
|
|
BaseWalkSpeed = 600.f;
|
|
AimWalkSpeed = 350.f;
|
|
}
|
|
|
|
void UCombatComponent::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
|
|
{
|
|
Super::GetLifetimeReplicatedProps(OutLifetimeProps);
|
|
|
|
DOREPLIFETIME(UCombatComponent, EquippedWeapon);
|
|
DOREPLIFETIME(UCombatComponent, bAiming);
|
|
DOREPLIFETIME_CONDITION(UCombatComponent, CarriedAmmo, COND_OwnerOnly);
|
|
DOREPLIFETIME(UCombatComponent, CombatState);
|
|
}
|
|
|
|
void UCombatComponent::BeginPlay()
|
|
{
|
|
Super::BeginPlay();
|
|
|
|
if (Character)
|
|
{
|
|
Character->GetCharacterMovement()->MaxWalkSpeed = BaseWalkSpeed;
|
|
|
|
if (Character->GetFollowCamera())
|
|
{
|
|
DefaultFOV = Character->GetFollowCamera()->FieldOfView;
|
|
CurrentFOV = DefaultFOV;
|
|
}
|
|
if (Character->HasAuthority())
|
|
{
|
|
InitializeCarriedAmmo();
|
|
}
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
|
|
{
|
|
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
|
|
|
|
if (Character && Character->IsLocallyControlled())
|
|
{
|
|
FHitResult HitResult;
|
|
TraceUnderCrosshairs(HitResult);
|
|
HitTarget = HitResult.ImpactPoint;
|
|
|
|
SetHUDCrosshairs(DeltaTime);
|
|
InterpFOV(DeltaTime);
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::FireButtonPressed(bool bPressed)
|
|
{
|
|
bFireButtonPressed = bPressed;
|
|
if (bFireButtonPressed && EquippedWeapon)
|
|
{
|
|
Fire();
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::Fire()
|
|
{
|
|
if (CanFire())
|
|
{
|
|
bCanFire = false;
|
|
ServerFire(HitTarget);
|
|
if (EquippedWeapon)
|
|
{
|
|
CrosshairShootingFactor = .75f;
|
|
}
|
|
StartFireTimer();
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::StartFireTimer()
|
|
{
|
|
if (EquippedWeapon == nullptr || Character == nullptr) return;
|
|
Character->GetWorldTimerManager().SetTimer(
|
|
FireTimer,
|
|
this,
|
|
&UCombatComponent::FireTimerFinished,
|
|
EquippedWeapon->FireDelay
|
|
);
|
|
}
|
|
|
|
void UCombatComponent::FireTimerFinished()
|
|
{
|
|
if (EquippedWeapon == nullptr) return;
|
|
bCanFire = true;
|
|
if (bFireButtonPressed && EquippedWeapon->bAutomatic)
|
|
{
|
|
Fire();
|
|
}
|
|
if (EquippedWeapon->IsEmpty())
|
|
{
|
|
Reload();
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::ServerFire_Implementation(const FVector_NetQuantize& TraceHitTarget)
|
|
{
|
|
MulticastFire(TraceHitTarget);
|
|
}
|
|
|
|
void UCombatComponent::MulticastFire_Implementation(const FVector_NetQuantize& TraceHitTarget)
|
|
{
|
|
if (EquippedWeapon == nullptr) return;
|
|
if (Character && CombatState == ECombatState::ECS_Unoccupied)
|
|
{
|
|
Character->PlayFireMontage(bAiming);
|
|
EquippedWeapon->Fire(TraceHitTarget);
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::EquipWeapon(AWeapon* WeaponToEquip)
|
|
{
|
|
if (Character == nullptr || WeaponToEquip == nullptr) return;
|
|
if (EquippedWeapon)
|
|
{
|
|
EquippedWeapon->Dropped();
|
|
}
|
|
EquippedWeapon = WeaponToEquip;
|
|
EquippedWeapon->SetWeaponState(EWeaponState::EWS_Equipped);
|
|
const USkeletalMeshSocket* HandSocket = Character->GetMesh()->GetSocketByName(FName("RightHandSocket"));
|
|
if (HandSocket)
|
|
{
|
|
HandSocket->AttachActor(EquippedWeapon, Character->GetMesh());
|
|
}
|
|
EquippedWeapon->SetOwner(Character);
|
|
EquippedWeapon->SetHUDAmmo();
|
|
|
|
if (CarriedAmmoMap.Contains(EquippedWeapon->GetWeaponType()))
|
|
{
|
|
CarriedAmmo = CarriedAmmoMap[EquippedWeapon->GetWeaponType()];
|
|
}
|
|
|
|
Controller = Controller == nullptr ? Cast<ABlasterPlayerController>(Character->Controller) : Controller;
|
|
if (Controller)
|
|
{
|
|
Controller->SetHUDCarriedAmmo(CarriedAmmo);
|
|
}
|
|
|
|
if (EquippedWeapon->EquipSound)
|
|
{
|
|
UGameplayStatics::PlaySoundAtLocation(
|
|
this,
|
|
EquippedWeapon->EquipSound,
|
|
Character->GetActorLocation()
|
|
);
|
|
}
|
|
|
|
if (EquippedWeapon->IsEmpty())
|
|
{
|
|
Reload();
|
|
}
|
|
|
|
Character->GetCharacterMovement()->bOrientRotationToMovement = false;
|
|
Character->bUseControllerRotationYaw = true;
|
|
}
|
|
|
|
void UCombatComponent::Reload()
|
|
{
|
|
if (CarriedAmmo > 0 && CombatState != ECombatState::ECS_Reloading)
|
|
{
|
|
ServerReload();
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::ServerReload_Implementation()
|
|
{
|
|
if (Character == nullptr || EquippedWeapon == nullptr) return;
|
|
|
|
// return if weapon mag is at max capacity
|
|
if (EquippedWeapon->GetAmmo() == EquippedWeapon->GetMagCapacity()) return;
|
|
|
|
CombatState = ECombatState::ECS_Reloading;
|
|
HandleReload();
|
|
}
|
|
|
|
void UCombatComponent::FinishedReloading()
|
|
{
|
|
if (Character == nullptr) return;
|
|
if (Character->HasAuthority())
|
|
{
|
|
CombatState = ECombatState::ECS_Unoccupied;
|
|
UpdateAmmoValues();
|
|
}
|
|
if (bFireButtonPressed)
|
|
{
|
|
Fire();
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::UpdateAmmoValues()
|
|
{
|
|
if (Character == nullptr || EquippedWeapon == nullptr) return;
|
|
int32 ReloadAmount = AmountToReload();
|
|
if (CarriedAmmoMap.Contains(EquippedWeapon->GetWeaponType()))
|
|
{
|
|
CarriedAmmoMap[EquippedWeapon->GetWeaponType()] -= ReloadAmount;
|
|
CarriedAmmo = CarriedAmmoMap[EquippedWeapon->GetWeaponType()];
|
|
}
|
|
Controller = Controller == nullptr ? Cast<ABlasterPlayerController>(Character->Controller) : Controller;
|
|
if (Controller)
|
|
{
|
|
Controller->SetHUDCarriedAmmo(CarriedAmmo);
|
|
}
|
|
EquippedWeapon->AddAmmo(-ReloadAmount);
|
|
}
|
|
|
|
void UCombatComponent::OnRep_CombatState()
|
|
{
|
|
switch (CombatState)
|
|
{
|
|
case ECombatState::ECS_Reloading:
|
|
HandleReload();
|
|
break;
|
|
case ECombatState::ECS_Unoccupied:
|
|
if (bFireButtonPressed)
|
|
{
|
|
Fire();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::HandleReload()
|
|
{
|
|
Character->PlayReloadMontage();
|
|
}
|
|
|
|
int32 UCombatComponent::AmountToReload()
|
|
{
|
|
if (EquippedWeapon == nullptr) return 0;
|
|
int32 RoomInMag = EquippedWeapon->GetMagCapacity() - EquippedWeapon->GetAmmo();
|
|
|
|
if (CarriedAmmoMap.Contains(EquippedWeapon->GetWeaponType()))
|
|
{
|
|
int32 AmountCarried = CarriedAmmoMap[EquippedWeapon->GetWeaponType()];
|
|
int32 Least = FMath::Min(RoomInMag, AmountCarried);
|
|
return FMath::Clamp(RoomInMag, 0, Least);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void UCombatComponent::OnRep_EquippedWeapon()
|
|
{
|
|
if (EquippedWeapon && Character)
|
|
{
|
|
EquippedWeapon->SetWeaponState(EWeaponState::EWS_Equipped);
|
|
const USkeletalMeshSocket* HandSocket = Character->GetMesh()->GetSocketByName(FName("RightHandSocket"));
|
|
if (HandSocket)
|
|
{
|
|
HandSocket->AttachActor(EquippedWeapon, Character->GetMesh());
|
|
}
|
|
Character->GetCharacterMovement()->bOrientRotationToMovement = false;
|
|
Character->bUseControllerRotationYaw = true;
|
|
|
|
if (EquippedWeapon->EquipSound)
|
|
{
|
|
UGameplayStatics::PlaySoundAtLocation(
|
|
this,
|
|
EquippedWeapon->EquipSound,
|
|
Character->GetActorLocation()
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::TraceUnderCrosshairs(FHitResult& TraceHitResult)
|
|
{
|
|
FVector2D ViewportSize;
|
|
if (GEngine && GEngine->GameViewport)
|
|
{
|
|
GEngine->GameViewport->GetViewportSize(ViewportSize);
|
|
}
|
|
|
|
FVector2D CrosshairLocation(ViewportSize.X / 2.f, ViewportSize.Y / 2.f);
|
|
FVector CrosshairWorldPosition;
|
|
FVector CrosshairWorldDirection;
|
|
bool bScreenToWorld = UGameplayStatics::DeprojectScreenToWorld(
|
|
UGameplayStatics::GetPlayerController(this, 0),
|
|
CrosshairLocation,
|
|
CrosshairWorldPosition,
|
|
CrosshairWorldDirection
|
|
);
|
|
|
|
if (bScreenToWorld)
|
|
{
|
|
FVector Start = CrosshairWorldPosition;
|
|
|
|
if (Character)
|
|
{
|
|
float DistanceToCharacter = (Character->GetActorLocation() - Start).Size();
|
|
Start += CrosshairWorldDirection * (DistanceToCharacter + 100.f);
|
|
}
|
|
|
|
FVector End = Start + CrosshairWorldDirection * TRACE_LENGTH;
|
|
|
|
GetWorld()->LineTraceSingleByChannel(
|
|
TraceHitResult,
|
|
Start,
|
|
End,
|
|
ECollisionChannel::ECC_Visibility
|
|
);
|
|
if (TraceHitResult.GetActor() && TraceHitResult.GetActor()->Implements<UInteractWithCrosshairInterface>())
|
|
{
|
|
HUDPackage.CrosshairsColor = FLinearColor::Red;
|
|
}
|
|
else
|
|
{
|
|
HUDPackage.CrosshairsColor = FLinearColor::White;
|
|
}
|
|
|
|
if (!TraceHitResult.bBlockingHit) TraceHitResult.ImpactPoint = End;
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::SetHUDCrosshairs(float DeltaTime)
|
|
{
|
|
if (Character == nullptr || Character->Controller == nullptr) return;
|
|
|
|
Controller = Controller == nullptr ? Cast<ABlasterPlayerController>(Character->Controller) : Controller;
|
|
if (Controller)
|
|
{
|
|
HUD = HUD == nullptr ? Cast<ABlasterHUD>(Controller->GetHUD()) : HUD;
|
|
if (HUD)
|
|
{
|
|
if (EquippedWeapon)
|
|
{
|
|
HUDPackage.CrosshairsCenter = EquippedWeapon->CrosshairsCenter;
|
|
HUDPackage.CrosshairsLeft = EquippedWeapon->CrosshairsLeft;
|
|
HUDPackage.CrosshairsRight = EquippedWeapon->CrosshairsRight;
|
|
HUDPackage.CrosshairsBottom = EquippedWeapon->CrosshairsBottom;
|
|
HUDPackage.CrosshairsTop = EquippedWeapon->CrosshairsTop;
|
|
}
|
|
else
|
|
{
|
|
HUDPackage.CrosshairsCenter = nullptr;
|
|
HUDPackage.CrosshairsLeft = nullptr;
|
|
HUDPackage.CrosshairsRight = nullptr;
|
|
HUDPackage.CrosshairsBottom = nullptr;
|
|
HUDPackage.CrosshairsTop = nullptr;
|
|
}
|
|
// Calculate crosshair spread
|
|
|
|
// [0, 600] -> [0, 1]
|
|
FVector2D WalkSpeedRange(0.f, Character->GetCharacterMovement()->MaxWalkSpeed);
|
|
FVector2D VelocityMultiplierRange(0.f, 1.f);
|
|
FVector Velocity = Character->GetVelocity();
|
|
Velocity.Z = 0.f;
|
|
|
|
CrosshairVelocityFactor = FMath::GetMappedRangeValueClamped(WalkSpeedRange, VelocityMultiplierRange, Velocity.Size());
|
|
|
|
if (Character->GetCharacterMovement()->IsFalling())
|
|
{
|
|
CrosshairInAirFactor = FMath::FInterpTo(CrosshairInAirFactor, 2.25f, DeltaTime, 2.25f);
|
|
}
|
|
else
|
|
{
|
|
CrosshairInAirFactor = FMath::FInterpTo(CrosshairInAirFactor, 0.f, DeltaTime, 30.f);
|
|
}
|
|
|
|
if (bAiming)
|
|
{
|
|
CrosshairAimFactor = FMath::FInterpTo(CrosshairAimFactor, 0.58f, DeltaTime, 30.f);
|
|
}
|
|
else
|
|
{
|
|
CrosshairAimFactor = FMath::FInterpTo(CrosshairAimFactor, 0.f, DeltaTime, 30.f);
|
|
}
|
|
|
|
CrosshairShootingFactor = FMath::FInterpTo(CrosshairShootingFactor, 0.f, DeltaTime, 40.f);
|
|
|
|
HUDPackage.CrosshairSpread =
|
|
0.5f +
|
|
CrosshairVelocityFactor +
|
|
CrosshairInAirFactor -
|
|
CrosshairAimFactor +
|
|
CrosshairShootingFactor;
|
|
|
|
HUD->SetHUDPackage(HUDPackage);
|
|
}
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::InterpFOV(float DeltaTime)
|
|
{
|
|
if (EquippedWeapon == nullptr) return;
|
|
|
|
if (bAiming)
|
|
{
|
|
CurrentFOV = FMath::FInterpTo(CurrentFOV, EquippedWeapon->GetZoomedFOV(), DeltaTime, EquippedWeapon->GetZoomInterpSpeed());
|
|
}
|
|
else
|
|
{
|
|
CurrentFOV = FMath::FInterpTo(CurrentFOV, DefaultFOV, DeltaTime, ZoomInterpSpeed);
|
|
}
|
|
if (Character && Character->GetFollowCamera())
|
|
{
|
|
Character->GetFollowCamera()->SetFieldOfView(CurrentFOV);
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::SetAiming(bool bIsAiming)
|
|
{
|
|
bAiming = bIsAiming;
|
|
ServerSetAiming(bIsAiming);
|
|
if (Character)
|
|
{
|
|
Character->GetCharacterMovement()->MaxWalkSpeed = bIsAiming ? AimWalkSpeed : BaseWalkSpeed;
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::ServerSetAiming_Implementation(bool bIsAiming)
|
|
{
|
|
bAiming = bIsAiming;
|
|
if (Character)
|
|
{
|
|
Character->GetCharacterMovement()->MaxWalkSpeed = bIsAiming ? AimWalkSpeed : BaseWalkSpeed;
|
|
}
|
|
}
|
|
|
|
bool UCombatComponent::CanFire()
|
|
{
|
|
if (EquippedWeapon == nullptr) return false;
|
|
return !EquippedWeapon->IsEmpty() && bCanFire && CombatState == ECombatState::ECS_Unoccupied;
|
|
}
|
|
|
|
void UCombatComponent::OnRep_CarriedAmmo()
|
|
{
|
|
Controller = Controller == nullptr ? Cast<ABlasterPlayerController>(Character->Controller) : Controller;
|
|
if (Controller)
|
|
{
|
|
Controller->SetHUDCarriedAmmo(CarriedAmmo);
|
|
}
|
|
}
|
|
|
|
void UCombatComponent::InitializeCarriedAmmo()
|
|
{
|
|
CarriedAmmoMap.Emplace(EWeaponType::EWT_AssaultRifle, StartingARAmmo);
|
|
CarriedAmmoMap.Emplace(EWeaponType::EWT_RocketLauncher, StartingRocketAmmo);
|
|
CarriedAmmoMap.Emplace(EWeaponType::EWT_Pistol, StartingPistolAmmo);
|
|
CarriedAmmoMap.Emplace(EWeaponType::EWT_SubmachineGun, StartingSMGAmmo);
|
|
CarriedAmmoMap.Emplace(EWeaponType::EWT_Shotgun, StartingShotgunAmmo);
|
|
}
|