Merge branch 'player-damages-display'

Source/LegumeMix/Private/Enemy/LMEnemy.cpp

@@ -6,6 +6,7 @@ ALMEnemy::ALMEnemy()
 {
 	PrimaryActorTick.bCanEverTick = true;
 	EnemyState = EEnemyState::EES_Chasing;
+	AttackingRadius = 100.f;
 	AttackingDamage = 0.f;
 }
 

Source/LegumeMix/Private/Player/LMPlayer.cpp

@@ -27,6 +27,17 @@ ALMPlayer::ALMPlayer()
 
 	SpreadStream = FRandomStream(FMath::Rand());
 	HealthComponent = CreateDefaultSubobject<ULMHealthComponent>(TEXT("HealthComponent"));
+
+	HitPeriodLengthInSeconds = 15.f;
+	bHitPeriodInProgress = false;
+	TimeOfTheLastDamage = 0.f;
+	HealthAtTheCurrentHitPeriodBeginning = 100.f;
+	CumulatedDamagesOnCurrentHitPeriod = 0.f;
+	PlayerViewOcclusionPercent = 0.f;
+	NextPlayerViewOcclusionPercent = 0.f;
+	PlayerViewOcclusionPercent = 0.f;
+	AlphaLerpForPlayerViewOcclusionPercent = 0.f;
+	
 }
 
 void ALMPlayer::BeginPlay()
@@ -37,9 +48,41 @@ void ALMPlayer::BeginPlay()
 
 	GetCamera()->SetFieldOfView(ULMUserSettings::GetLegumixUserSettings()->FieldOfView);
 
-
+	HealthComponent->OnHealthChanged.AddDynamic(this, &ALMPlayer::SetDisplayDamageParameters);
 }
 
+void ALMPlayer::Tick(float DeltaTime)
+{
+	if(bHitPeriodInProgress == true)
+	{
+		double TimeElapsedSinceLastDamage = GetWorld()->GetTimeSeconds() - TimeOfTheLastDamage;
+		if(TimeElapsedSinceLastDamage > HitPeriodLengthInSeconds)
+		{
+			if(bHitPeriodInProgress == true)
+			{
+				bHitPeriodInProgress = false;
+				PlayerViewOcclusionPercent = NextPlayerViewOcclusionPercent;
+				NextPlayerViewOcclusionPercent = 0.f;
+				AlphaLerpForPlayerViewOcclusionPercent = 0.f;
+				TimeOfTheLastDamage = 0.f;
+				CumulatedDamagesOnCurrentHitPeriod = 0.f;
+			}
+		}
+	}
+	
+	if(PlayerViewOcclusionPercent != NextPlayerViewOcclusionPercent)
+	{
+		AlphaLerpForPlayerViewOcclusionPercent = FMath::Clamp(AlphaLerpForPlayerViewOcclusionPercent + DeltaTime, 0, 1);
+		PlayerViewOcclusionPercent = FMath::Lerp(PlayerViewOcclusionPercent, NextPlayerViewOcclusionPercent, AlphaLerpForPlayerViewOcclusionPercent);
+		DamageDynamicMaterialInstance->SetScalarParameterValue("PlayerViewOcclusionPercent", PlayerViewOcclusionPercent);	
+	}
+	else if(PlayerViewOcclusionPercent == NextPlayerViewOcclusionPercent)
+	{
+		AlphaLerpForPlayerViewOcclusionPercent = 0;
+	}
+}
+
+
 bool ALMPlayer::PickUpAmmo(ALMAmmo* Ammo)
 {
 	if (GEngine)
@@ -159,3 +202,25 @@ USkeletalMeshComponent* ALMPlayer::GetArms()
 	return ArmsMesh;
 }
 
+void ALMPlayer::SetDisplayDamageParameters(float Health, float Damage)
+{
+	if (bHitPeriodInProgress == false)
+	{
+		HealthAtTheCurrentHitPeriodBeginning = Health;
+		bHitPeriodInProgress  = true;
+	}
+	TimeOfTheLastDamage = GetWorld()->GetTimeSeconds();
+	CumulatedDamagesOnCurrentHitPeriod += Damage;
+	SetPlayerViewOcclusionPercent();
+}
+
+
+
+void ALMPlayer::SetPlayerViewOcclusionPercent()
+{
+	AlphaLerpForPlayerViewOcclusionPercent = 0;
+	PlayerViewOcclusionPercent = NextPlayerViewOcclusionPercent;
+	NextPlayerViewOcclusionPercent = CumulatedDamagesOnCurrentHitPeriod / HealthAtTheCurrentHitPeriodBeginning;
+}
+
+

Source/LegumeMix/Public/Enemy/LMEnemy.h

@@ -44,7 +44,7 @@ protected:
 	double GetDistanceToTarget(const AActor* TargetedActor);
 
 	/**
-	* Returns the distance between the enemy and a target.
+	* Performs an attack on the targeted pawn
 	* @param TargetedPawn 
 	* @returns
 	*/

Source/LegumeMix/Public/Player/LMHealthComponent.h

@@ -23,6 +23,8 @@ public:
 	void Kill();
 
 public:
+	FORCEINLINE float GetHealth() const { return Health; }
+	
 	/**
 	 * Applies an amount of damage to the component.
 	 * @param Damage The damage to apply the Health to.

Source/LegumeMix/Public/Player/LMPlayer.h

@@ -11,6 +11,7 @@
 class UCameraComponent;
 class ULMWeaponManager;
 class ULMHealthComponent;
+class UMaterialInstanceDynamic;
 class ALMAmmo;
 
 DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnRequestUnpauseSignature);
@@ -48,6 +49,9 @@ protected:
 	// Called when the game starts or when spawned
 	virtual void BeginPlay() override;
 
+	// Called every frame
+	virtual void Tick(float DeltaTime) override;
+
 public:	
 	UFUNCTION(BlueprintCallable)
 	ULMWeaponManager* GetWeaponManager() { return WeaponManager; }
@@ -113,6 +117,76 @@ private:
 	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
 	TObjectPtr<ULMHealthComponent> HealthComponent;
 
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Legumix, meta = (AllowPrivateAccess = true))
+	TObjectPtr<UMaterialInstanceDynamic> DamageDynamicMaterialInstance;
+
+	/**
+	 * Is a hit period in progress
+	 */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Legumix, meta = (AllowPrivateAccess = true))
+	bool bHitPeriodInProgress;
+	
+	/**
+	 * Length of the period in which the damage texture effect will be displayed on player screen.
+	 */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Legumix, meta = (AllowPrivateAccess = true))
+	double HitPeriodLengthInSeconds;
+	
+	/**
+	 * Time of last damage taken.
+	 * If the time elapsed since is superior to the HitPeriodLengthInSeconds variable, ends the Hit period
+	 * and so the displaying the damage texture effect  on player screen
+	 */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
+	double TimeOfTheLastDamage;
+
+	/**
+	 * Cumulated damages taken by the player on the current hit period
+	 * To calculate view occlusion percent for the damage texture effect 
+	 */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
+	float CumulatedDamagesOnCurrentHitPeriod;
+
+	/**
+	 * Player health at the current hit period beginning
+	 * To calculate view occlusion percent for the damage texture effect 
+	 */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
+	float HealthAtTheCurrentHitPeriodBeginning;
+
+	/**
+	 * Percent of the player screen occupied with damage texture effect to reach 
+	 */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
+	float NextPlayerViewOcclusionPercent;
+
+	/**
+	 * Previous percent of the player screen occupied with damage texture effect
+	 * mandatory to make interpolation between this core and the current one
+	 */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Legumix, meta = (AllowPrivateAccess = true))
+	float PlayerViewOcclusionPercent;
+	
+	/**
+	 * Percent of the player screen occupied with damage texture effect 
+	 */
+	UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category=Legumix, meta = (AllowPrivateAccess = true))
+	float AlphaLerpForPlayerViewOcclusionPercent;
+
+	/**
+	 * Actualize all parameters needed to calculate PlayerViewOcclusionPercent 
+	 */
+	UFUNCTION(BlueprintCallable, Category=PostProcess)
+	void SetDisplayDamageParameters(float Health, float Damage);
+		
+	/**
+	 * Determine Percent of the player screen occupied with damage texture effect 
+	 */
+	UFUNCTION(BlueprintCallable, Category=PostProcess)
+	void SetPlayerViewOcclusionPercent();
+
+
+
 private:
 #if WITH_EDITORONLY_DATA
 	/** If set, bullet debug will be drawn. */