Upload folder using huggingface_hub

Source/Pockmon.Target.cs

@@ -0,0 +1,15 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+using UnrealBuildTool;
+using System.Collections.Generic;
+
+public class PockmonTarget : TargetRules
+{
+	public PockmonTarget(TargetInfo Target) : base(Target)
+	{
+		Type = TargetType.Game;
+		DefaultBuildSettings = BuildSettingsVersion.V6;
+		IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_7;
+		ExtraModuleNames.Add("Pockmon");
+	}
+}

Source/Pockmon/Pockmon.Build.cs

@@ -0,0 +1,51 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+using UnrealBuildTool;
+
+public class Pockmon : ModuleRules
+{
+	public Pockmon(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+
+		PublicDependencyModuleNames.AddRange(new string[] {
+			"Core",
+			"CoreUObject",
+			"Engine",
+			"InputCore",
+			"EnhancedInput",
+			"AIModule",
+			"StateTreeModule",
+			"GameplayStateTreeModule",
+			"UMG",
+			"Slate"
+		});
+
+		PrivateDependencyModuleNames.AddRange(new string[] { });
+
+		PublicIncludePaths.AddRange(new string[] {
+			"Pockmon",
+			"Pockmon/Variant_Platforming",
+			"Pockmon/Variant_Platforming/Animation",
+			"Pockmon/Variant_Combat",
+			"Pockmon/Variant_Combat/AI",
+			"Pockmon/Variant_Combat/Animation",
+			"Pockmon/Variant_Combat/Gameplay",
+			"Pockmon/Variant_Combat/Interfaces",
+			"Pockmon/Variant_Combat/UI",
+			"Pockmon/Variant_SideScrolling",
+			"Pockmon/Variant_SideScrolling/AI",
+			"Pockmon/Variant_SideScrolling/Gameplay",
+			"Pockmon/Variant_SideScrolling/Interfaces",
+			"Pockmon/Variant_SideScrolling/UI"
+		});
+
+		// Uncomment if you are using Slate UI
+		// PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });
+
+		// Uncomment if you are using online features
+		// PrivateDependencyModuleNames.Add("OnlineSubsystem");
+
+		// To include OnlineSubsystemSteam, add it to the plugins section in your uproject file with the Enabled attribute set to true
+	}
+}

Source/Pockmon/Pockmon.cpp

@@ -0,0 +1,8 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "Pockmon.h"
+#include "Modules/ModuleManager.h"
+
+IMPLEMENT_PRIMARY_GAME_MODULE( FDefaultGameModuleImpl, Pockmon, "Pockmon" );
+
+DEFINE_LOG_CATEGORY(LogPockmon)

Source/Pockmon/Pockmon.h

@@ -0,0 +1,8 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+
+/** Main log category used across the project */
+DECLARE_LOG_CATEGORY_EXTERN(LogPockmon, Log, All);

Source/Pockmon/PockmonCharacter.cpp

@@ -0,0 +1,133 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "PockmonCharacter.h"
+#include "Engine/LocalPlayer.h"
+#include "Camera/CameraComponent.h"
+#include "Components/CapsuleComponent.h"
+#include "GameFramework/CharacterMovementComponent.h"
+#include "GameFramework/SpringArmComponent.h"
+#include "GameFramework/Controller.h"
+#include "EnhancedInputComponent.h"
+#include "EnhancedInputSubsystems.h"
+#include "InputActionValue.h"
+#include "Pockmon.h"
+
+APockmonCharacter::APockmonCharacter()
+{
+	// Set size for collision capsule
+	GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);
+		
+	// Don't rotate when the controller rotates. Let that just affect the camera.
+	bUseControllerRotationPitch = false;
+	bUseControllerRotationYaw = false;
+	bUseControllerRotationRoll = false;
+
+	// Configure character movement
+	GetCharacterMovement()->bOrientRotationToMovement = true;
+	GetCharacterMovement()->RotationRate = FRotator(0.0f, 500.0f, 0.0f);
+
+	// Note: For faster iteration times these variables, and many more, can be tweaked in the Character Blueprint
+	// instead of recompiling to adjust them
+	GetCharacterMovement()->JumpZVelocity = 500.f;
+	GetCharacterMovement()->AirControl = 0.35f;
+	GetCharacterMovement()->MaxWalkSpeed = 500.f;
+	GetCharacterMovement()->MinAnalogWalkSpeed = 20.f;
+	GetCharacterMovement()->BrakingDecelerationWalking = 2000.f;
+	GetCharacterMovement()->BrakingDecelerationFalling = 1500.0f;
+
+	// Create a camera boom (pulls in towards the player if there is a collision)
+	CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
+	CameraBoom->SetupAttachment(RootComponent);
+	CameraBoom->TargetArmLength = 400.0f;
+	CameraBoom->bUsePawnControlRotation = true;
+
+	// Create a follow camera
+	FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
+	FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName);
+	FollowCamera->bUsePawnControlRotation = false;
+
+	// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character) 
+	// are set in the derived blueprint asset named ThirdPersonCharacter (to avoid direct content references in C++)
+}
+
+void APockmonCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
+{
+	// Set up action bindings
+	if (UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent)) {
+		
+		// Jumping
+		EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Started, this, &ACharacter::Jump);
+		EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Completed, this, &ACharacter::StopJumping);
+
+		// Moving
+		EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &APockmonCharacter::Move);
+		EnhancedInputComponent->BindAction(MouseLookAction, ETriggerEvent::Triggered, this, &APockmonCharacter::Look);
+
+		// Looking
+		EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &APockmonCharacter::Look);
+	}
+	else
+	{
+		UE_LOG(LogPockmon, Error, TEXT("'%s' Failed to find an Enhanced Input component! This template is built to use the Enhanced Input system. If you intend to use the legacy system, then you will need to update this C++ file."), *GetNameSafe(this));
+	}
+}
+
+void APockmonCharacter::Move(const FInputActionValue& Value)
+{
+	// input is a Vector2D
+	FVector2D MovementVector = Value.Get<FVector2D>();
+
+	// route the input
+	DoMove(MovementVector.X, MovementVector.Y);
+}
+
+void APockmonCharacter::Look(const FInputActionValue& Value)
+{
+	// input is a Vector2D
+	FVector2D LookAxisVector = Value.Get<FVector2D>();
+
+	// route the input
+	DoLook(LookAxisVector.X, LookAxisVector.Y);
+}
+
+void APockmonCharacter::DoMove(float Right, float Forward)
+{
+	if (GetController() != nullptr)
+	{
+		// find out which way is forward
+		const FRotator Rotation = GetController()->GetControlRotation();
+		const FRotator YawRotation(0, Rotation.Yaw, 0);
+
+		// get forward vector
+		const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
+
+		// get right vector 
+		const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
+
+		// add movement 
+		AddMovementInput(ForwardDirection, Forward);
+		AddMovementInput(RightDirection, Right);
+	}
+}
+
+void APockmonCharacter::DoLook(float Yaw, float Pitch)
+{
+	if (GetController() != nullptr)
+	{
+		// add yaw and pitch input to controller
+		AddControllerYawInput(Yaw);
+		AddControllerPitchInput(Pitch);
+	}
+}
+
+void APockmonCharacter::DoJumpStart()
+{
+	// signal the character to jump
+	Jump();
+}
+
+void APockmonCharacter::DoJumpEnd()
+{
+	// signal the character to stop jumping
+	StopJumping();
+}

Source/Pockmon/PockmonCharacter.h

@@ -0,0 +1,96 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Character.h"
+#include "Logging/LogMacros.h"
+#include "PockmonCharacter.generated.h"
+
+class USpringArmComponent;
+class UCameraComponent;
+class UInputAction;
+struct FInputActionValue;
+
+DECLARE_LOG_CATEGORY_EXTERN(LogTemplateCharacter, Log, All);
+
+/**
+ *  A simple player-controllable third person character
+ *  Implements a controllable orbiting camera
+ */
+UCLASS(abstract)
+class APockmonCharacter : public ACharacter
+{
+	GENERATED_BODY()
+
+	/** Camera boom positioning the camera behind the character */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components", meta = (AllowPrivateAccess = "true"))
+	USpringArmComponent* CameraBoom;
+
+	/** Follow camera */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components", meta = (AllowPrivateAccess = "true"))
+	UCameraComponent* FollowCamera;
+	
+protected:
+
+	/** Jump Input Action */
+	UPROPERTY(EditAnywhere, Category="Input")
+	UInputAction* JumpAction;
+
+	/** Move Input Action */
+	UPROPERTY(EditAnywhere, Category="Input")
+	UInputAction* MoveAction;
+
+	/** Look Input Action */
+	UPROPERTY(EditAnywhere, Category="Input")
+	UInputAction* LookAction;
+
+	/** Mouse Look Input Action */
+	UPROPERTY(EditAnywhere, Category="Input")
+	UInputAction* MouseLookAction;
+
+public:
+
+	/** Constructor */
+	APockmonCharacter();	
+
+protected:
+
+	/** Initialize input action bindings */
+	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
+
+protected:
+
+	/** Called for movement input */
+	void Move(const FInputActionValue& Value);
+
+	/** Called for looking input */
+	void Look(const FInputActionValue& Value);
+
+public:
+
+	/** Handles move inputs from either controls or UI interfaces */
+	UFUNCTION(BlueprintCallable, Category="Input")
+	virtual void DoMove(float Right, float Forward);
+
+	/** Handles look inputs from either controls or UI interfaces */
+	UFUNCTION(BlueprintCallable, Category="Input")
+	virtual void DoLook(float Yaw, float Pitch);
+
+	/** Handles jump pressed inputs from either controls or UI interfaces */
+	UFUNCTION(BlueprintCallable, Category="Input")
+	virtual void DoJumpStart();
+
+	/** Handles jump pressed inputs from either controls or UI interfaces */
+	UFUNCTION(BlueprintCallable, Category="Input")
+	virtual void DoJumpEnd();
+
+public:
+
+	/** Returns CameraBoom subobject **/
+	FORCEINLINE class USpringArmComponent* GetCameraBoom() const { return CameraBoom; }
+
+	/** Returns FollowCamera subobject **/
+	FORCEINLINE class UCameraComponent* GetFollowCamera() const { return FollowCamera; }
+};
+

Source/Pockmon/PockmonGameMode.cpp

@@ -0,0 +1,8 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "PockmonGameMode.h"
+
+APockmonGameMode::APockmonGameMode()
+{
+	// stub
+}

Source/Pockmon/PockmonGameMode.h

@@ -0,0 +1,24 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/GameModeBase.h"
+#include "PockmonGameMode.generated.h"
+
+/**
+ *  Simple GameMode for a third person game
+ */
+UCLASS(abstract)
+class APockmonGameMode : public AGameModeBase
+{
+	GENERATED_BODY()
+
+public:
+	
+	/** Constructor */
+	APockmonGameMode();
+};
+
+
+

Source/Pockmon/PockmonPlayerController.cpp

@@ -0,0 +1,67 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "PockmonPlayerController.h"
+#include "EnhancedInputSubsystems.h"
+#include "Engine/LocalPlayer.h"
+#include "InputMappingContext.h"
+#include "Blueprint/UserWidget.h"
+#include "Pockmon.h"
+#include "Widgets/Input/SVirtualJoystick.h"
+
+void APockmonPlayerController::BeginPlay()
+{
+	Super::BeginPlay();
+
+	// only spawn touch controls on local player controllers
+	if (ShouldUseTouchControls() && IsLocalPlayerController())
+	{
+		// spawn the mobile controls widget
+		MobileControlsWidget = CreateWidget<UUserWidget>(this, MobileControlsWidgetClass);
+
+		if (MobileControlsWidget)
+		{
+			// add the controls to the player screen
+			MobileControlsWidget->AddToPlayerScreen(0);
+
+		} else {
+
+			UE_LOG(LogPockmon, Error, TEXT("Could not spawn mobile controls widget."));
+
+		}
+
+	}
+}
+
+void APockmonPlayerController::SetupInputComponent()
+{
+	Super::SetupInputComponent();
+
+	// only add IMCs for local player controllers
+	if (IsLocalPlayerController())
+	{
+		// Add Input Mapping Contexts
+		if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(GetLocalPlayer()))
+		{
+			for (UInputMappingContext* CurrentContext : DefaultMappingContexts)
+			{
+				Subsystem->AddMappingContext(CurrentContext, 0);
+			}
+
+			// only add these IMCs if we're not using mobile touch input
+			if (!ShouldUseTouchControls())
+			{
+				for (UInputMappingContext* CurrentContext : MobileExcludedMappingContexts)
+				{
+					Subsystem->AddMappingContext(CurrentContext, 0);
+				}
+			}
+		}
+	}
+}
+
+bool APockmonPlayerController::ShouldUseTouchControls() const
+{
+	// are we on a mobile platform? Should we force touch?
+	return SVirtualJoystick::ShouldDisplayTouchInterface() || bForceTouchControls;
+}

Source/Pockmon/PockmonPlayerController.h

@@ -0,0 +1,52 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/PlayerController.h"
+#include "PockmonPlayerController.generated.h"
+
+class UInputMappingContext;
+class UUserWidget;
+
+/**
+ *  Basic PlayerController class for a third person game
+ *  Manages input mappings
+ */
+UCLASS(abstract)
+class APockmonPlayerController : public APlayerController
+{
+	GENERATED_BODY()
+	
+protected:
+
+	/** Input Mapping Contexts */
+	UPROPERTY(EditAnywhere, Category ="Input|Input Mappings")
+	TArray<UInputMappingContext*> DefaultMappingContexts;
+
+	/** Input Mapping Contexts */
+	UPROPERTY(EditAnywhere, Category="Input|Input Mappings")
+	TArray<UInputMappingContext*> MobileExcludedMappingContexts;
+
+	/** Mobile controls widget to spawn */
+	UPROPERTY(EditAnywhere, Category="Input|Touch Controls")
+	TSubclassOf<UUserWidget> MobileControlsWidgetClass;
+
+	/** Pointer to the mobile controls widget */
+	UPROPERTY()
+	TObjectPtr<UUserWidget> MobileControlsWidget;
+
+	/** If true, the player will use UMG touch controls even if not playing on mobile platforms */
+	UPROPERTY(EditAnywhere, Config, Category = "Input|Touch Controls")
+	bool bForceTouchControls = false;
+
+	/** Gameplay initialization */
+	virtual void BeginPlay() override;
+
+	/** Input mapping context setup */
+	virtual void SetupInputComponent() override;
+
+	/** Returns true if the player should use UMG touch controls */
+	bool ShouldUseTouchControls() const;
+
+};

Source/Pockmon/Variant_Combat/AI/CombatAIController.cpp

@@ -0,0 +1,19 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatAIController.h"
+#include "Components/StateTreeAIComponent.h"
+
+ACombatAIController::ACombatAIController()
+{
+	// create the StateTree AI Component
+	StateTreeAI = CreateDefaultSubobject<UStateTreeAIComponent>(TEXT("StateTreeAI"));
+	check(StateTreeAI);
+
+	// ensure we start the StateTree when we possess the pawn
+	bStartAILogicOnPossess = true;
+
+	// ensure we're attached to the possessed character.
+	// this is necessary for EnvQueries to work correctly
+	bAttachToPawn = true;
+}

Source/Pockmon/Variant_Combat/AI/CombatAIController.h

@@ -0,0 +1,27 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "AIController.h"
+#include "CombatAIController.generated.h"
+
+class UStateTreeAIComponent;
+
+/**
+ *	A basic AI Controller capable of running StateTree
+ */
+UCLASS(abstract)
+class ACombatAIController : public AAIController
+{
+	GENERATED_BODY()
+
+	/** StateTree Component */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components", meta = (AllowPrivateAccess = "true"))
+	UStateTreeAIComponent* StateTreeAI;
+
+public:
+
+	/** Constructor */
+	ACombatAIController();
+};

Source/Pockmon/Variant_Combat/AI/CombatEnemy.cpp

@@ -0,0 +1,343 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatEnemy.h"
+#include "Components/CapsuleComponent.h"
+#include "GameFramework/CharacterMovementComponent.h"
+#include "CombatAIController.h"
+#include "Components/WidgetComponent.h"
+#include "Engine/DamageEvents.h"
+#include "CombatLifeBar.h"
+#include "TimerManager.h"
+#include "Components/SkeletalMeshComponent.h"
+#include "Animation/AnimInstance.h"
+
+ACombatEnemy::ACombatEnemy()
+{
+	PrimaryActorTick.bCanEverTick = true;
+
+	// bind the attack montage ended delegate
+	OnAttackMontageEnded.BindUObject(this, &ACombatEnemy::AttackMontageEnded);
+
+	// set the AI Controller class by default
+	AIControllerClass = ACombatAIController::StaticClass();
+
+	// use an AI Controller regardless of whether we're placed or spawned
+	AutoPossessAI = EAutoPossessAI::PlacedInWorldOrSpawned;
+
+	// ignore the controller's yaw rotation
+	bUseControllerRotationYaw = false;
+
+	// create the life bar
+	LifeBar = CreateDefaultSubobject<UWidgetComponent>(TEXT("LifeBar"));
+	LifeBar->SetupAttachment(RootComponent);
+
+	// set the collision capsule size
+	GetCapsuleComponent()->SetCapsuleSize(35.0f, 90.0f);
+
+	// set the character movement properties
+	GetCharacterMovement()->bUseControllerDesiredRotation = true;
+
+	// reset HP to maximum
+	CurrentHP = MaxHP;
+}
+
+void ACombatEnemy::DoAIComboAttack()
+{
+	// ignore if we're already playing an attack animation
+	if (bIsAttacking)
+	{
+		return;
+	}
+
+	// raise the attacking flag
+	bIsAttacking = true;
+
+	// choose how many times we're going to attack
+	TargetComboCount = FMath::RandRange(1, ComboSectionNames.Num() - 1);
+
+	// reset the attack counter
+	CurrentComboAttack = 0;
+
+	// play the attack montage
+	if (UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance())
+	{
+		const float MontageLength = AnimInstance->Montage_Play(ComboAttackMontage, 1.0f, EMontagePlayReturnType::MontageLength, 0.0f, true);
+
+		// subscribe to montage completed and interrupted events
+		if (MontageLength > 0.0f)
+		{
+			// set the end delegate for the montage
+			AnimInstance->Montage_SetEndDelegate(OnAttackMontageEnded, ComboAttackMontage);
+		}
+	}
+}
+
+void ACombatEnemy::DoAIChargedAttack()
+{
+	// ignore if we're already playing an attack animation
+	if (bIsAttacking)
+	{
+		return;
+	}
+
+	// raise the attacking flag
+	bIsAttacking = true;
+
+	// choose how many loops are we going to charge for
+	TargetChargeLoops = FMath::RandRange(MinChargeLoops, MaxChargeLoops);
+
+	// reset the charge loop counter
+	CurrentChargeLoop = 0;
+
+	// play the attack montage
+	if (UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance())
+	{
+		const float MontageLength = AnimInstance->Montage_Play(ChargedAttackMontage, 1.0f, EMontagePlayReturnType::MontageLength, 0.0f, true);
+
+		// subscribe to montage completed and interrupted events
+		if (MontageLength > 0.0f)
+		{
+			// set the end delegate for the montage
+			AnimInstance->Montage_SetEndDelegate(OnAttackMontageEnded, ChargedAttackMontage);
+		}
+	}
+}
+
+void ACombatEnemy::AttackMontageEnded(UAnimMontage* Montage, bool bInterrupted)
+{
+	// reset the attacking flag
+	bIsAttacking = false;
+
+	// call the attack completed delegate so the StateTree can continue execution
+	OnAttackCompleted.ExecuteIfBound();
+}
+
+const FVector& ACombatEnemy::GetLastDangerLocation() const
+{
+	return LastDangerLocation;
+}
+
+float ACombatEnemy::GetLastDangerTime() const
+{
+	return LastDangerTime;
+}
+
+void ACombatEnemy::DoAttackTrace(FName DamageSourceBone)
+{
+	// sweep for objects in front of the character to be hit by the attack
+	TArray<FHitResult> OutHits;
+
+	// start at the provided socket location, sweep forward
+	const FVector TraceStart = GetMesh()->GetSocketLocation(DamageSourceBone);
+	const FVector TraceEnd = TraceStart + (GetActorForwardVector() * MeleeTraceDistance);
+
+	// enemies only affect Pawn collision objects; they don't knock back boxes
+	FCollisionObjectQueryParams ObjectParams;
+	ObjectParams.AddObjectTypesToQuery(ECC_Pawn);
+
+	// use a sphere shape for the sweep
+	FCollisionShape CollisionShape;
+	CollisionShape.SetSphere(MeleeTraceRadius);
+
+	// ignore self
+	FCollisionQueryParams QueryParams;
+	QueryParams.AddIgnoredActor(this);
+
+	if (GetWorld()->SweepMultiByObjectType(OutHits, TraceStart, TraceEnd, FQuat::Identity, ObjectParams, CollisionShape, QueryParams))
+	{
+		// iterate over each object hit
+		for (const FHitResult& CurrentHit : OutHits)
+		{
+			/** does the actor have the player tag? */
+			if (CurrentHit.GetActor()->ActorHasTag(FName("Player")))
+			{
+				// check if the actor is damageable
+				ICombatDamageable* Damageable = Cast<ICombatDamageable>(CurrentHit.GetActor());
+
+				if (Damageable)
+				{
+					// knock upwards and away from the impact normal
+					const FVector Impulse = (CurrentHit.ImpactNormal * -MeleeKnockbackImpulse) + (FVector::UpVector * MeleeLaunchImpulse);
+
+					// pass the damage event to the actor
+					Damageable->ApplyDamage(MeleeDamage, this, CurrentHit.ImpactPoint, Impulse);
+
+				}
+			}
+		}
+	}
+}
+
+void ACombatEnemy::CheckCombo()
+{
+	// increase the combo counter
+	++CurrentComboAttack;
+
+	// do we still have attacks to play in this string?
+	if (CurrentComboAttack < TargetComboCount)
+	{
+		// jump to the next attack section
+		if (UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance())
+		{
+			AnimInstance->Montage_JumpToSection(ComboSectionNames[CurrentComboAttack], ComboAttackMontage);
+		}
+	}
+}
+
+void ACombatEnemy::CheckChargedAttack()
+{
+	// increase the charge loop counter
+	++CurrentChargeLoop;
+
+	// jump to either the loop or attack section of the montage depending on whether we hit the loop target
+	if (UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance())
+	{
+		AnimInstance->Montage_JumpToSection(CurrentChargeLoop >= TargetChargeLoops ? ChargeAttackSection : ChargeLoopSection, ChargedAttackMontage);
+	}
+}
+
+void ACombatEnemy::ApplyDamage(float Damage, AActor* DamageCauser, const FVector& DamageLocation, const FVector& DamageImpulse)
+{
+	
+	// pass the damage event to the actor
+	FDamageEvent DamageEvent;
+	const float ActualDamage = TakeDamage(Damage, DamageEvent, nullptr, DamageCauser);
+
+	// only process knockback and effects if we received nonzero damage
+	if (ActualDamage > 0.0f)
+	{
+		// apply the knockback impulse
+		GetCharacterMovement()->AddImpulse(DamageImpulse, true);
+
+		// is the character ragdolling?
+		if (GetMesh()->IsSimulatingPhysics())
+		{
+			// apply an impulse to the ragdoll
+			GetMesh()->AddImpulseAtLocation(DamageImpulse * GetMesh()->GetMass(), DamageLocation);
+		}
+
+		// stop the attack montages to interrupt the attack
+		if (UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance())
+		{
+			AnimInstance->Montage_Stop(0.1f, ComboAttackMontage);
+			AnimInstance->Montage_Stop(0.1f, ChargedAttackMontage);
+		}
+
+		// pass control to BP to play effects, etc.
+		ReceivedDamage(ActualDamage, DamageLocation, DamageImpulse.GetSafeNormal());
+	}
+}
+
+void ACombatEnemy::HandleDeath()
+{
+	// hide the life bar
+	LifeBar->SetHiddenInGame(true);
+
+	// disable the collision capsule to avoid being hit again while dead
+	GetCapsuleComponent()->SetCollisionEnabled(ECollisionEnabled::NoCollision);
+
+	// disable character movement
+	GetCharacterMovement()->DisableMovement();
+
+	// enable full ragdoll physics
+	GetMesh()->SetSimulatePhysics(true);
+
+	// call the died delegate to notify any subscribers
+	OnEnemyDied.Broadcast();
+
+	// set up the death timer
+	GetWorld()->GetTimerManager().SetTimer(DeathTimer, this, &ACombatEnemy::RemoveFromLevel, DeathRemovalTime);
+}
+
+void ACombatEnemy::ApplyHealing(float Healing, AActor* Healer)
+{
+	// stub
+}
+
+void ACombatEnemy::NotifyDanger(const FVector& DangerLocation, AActor* DangerSource)
+{
+	// ensure we're being attacked by the player
+	if (DangerSource && DangerSource->ActorHasTag(FName("Player")))
+	{
+		// save the danger location and game time
+		LastDangerLocation = DangerLocation;
+		LastDangerTime = GetWorld()->GetTimeSeconds();
+	}
+}
+
+void ACombatEnemy::RemoveFromLevel()
+{
+	// destroy this actor
+	Destroy();
+}
+
+float ACombatEnemy::TakeDamage(float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser)
+{
+	// only process damage if the character is still alive
+	if (CurrentHP <= 0.0f)
+	{
+		return 0.0f;
+	}
+
+	// reduce the current HP
+	CurrentHP -= Damage;
+
+	// have we run out of HP?
+	if (CurrentHP <= 0.0f)
+	{
+		// die
+		HandleDeath();
+	}
+	else
+	{
+		// update the life bar
+		LifeBarWidget->SetLifePercentage(CurrentHP / MaxHP);
+
+		// enable partial ragdoll physics, but keep the pelvis vertical
+		GetMesh()->SetPhysicsBlendWeight(0.5f);
+		GetMesh()->SetBodySimulatePhysics(PelvisBoneName, false);
+	}
+
+	// return the received damage amount
+	return Damage;
+}
+
+void ACombatEnemy::Landed(const FHitResult& Hit)
+{
+	Super::Landed(Hit);
+
+	// is the character still alive?
+	if (CurrentHP >= 0.0f)
+	{
+		// disable ragdoll physics
+		GetMesh()->SetPhysicsBlendWeight(0.0f);
+	}
+
+	// call the landed Delegate for StateTree
+	OnEnemyLanded.ExecuteIfBound();
+}
+
+void ACombatEnemy::BeginPlay()
+{
+	// reset HP to maximum
+	CurrentHP = MaxHP;
+
+	// we top the HP before BeginPlay so StateTree picks it up at the right value
+	Super::BeginPlay();
+
+	// get the life bar widget from the widget comp
+	LifeBarWidget = Cast<UCombatLifeBar>(LifeBar->GetUserWidgetObject());
+	check(LifeBarWidget);
+
+	// fill the life bar
+	LifeBarWidget->SetLifePercentage(1.0f);
+}
+
+void ACombatEnemy::EndPlay(EEndPlayReason::Type EndPlayReason)
+{
+	Super::EndPlay(EndPlayReason);
+
+	// clear the death timer
+	GetWorld()->GetTimerManager().ClearTimer(DeathTimer);
+}

Source/Pockmon/Variant_Combat/AI/CombatEnemy.h

@@ -0,0 +1,232 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Character.h"
+#include "CombatAttacker.h"
+#include "CombatDamageable.h"
+#include "Animation/AnimMontage.h"
+#include "Engine/TimerHandle.h"
+#include "CombatEnemy.generated.h"
+
+class UWidgetComponent;
+class UCombatLifeBar;
+class UAnimMontage;
+
+/** Completed attack animation delegate for StateTree */
+DECLARE_DELEGATE(FOnEnemyAttackCompleted);
+
+/** Landed delegate for StateTree */
+DECLARE_DELEGATE(FOnEnemyLanded);
+
+/** Enemy died delegate */
+DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnEnemyDied);
+
+/**
+ *  An AI-controlled character with combat capabilities.
+ *  Its bundled AI Controller runs logic through StateTree
+ */
+UCLASS(abstract)
+class ACombatEnemy : public ACharacter, public ICombatAttacker, public ICombatDamageable
+{
+	GENERATED_BODY()
+
+	/** Life bar widget component */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components", meta = (AllowPrivateAccess = "true"))
+	UWidgetComponent* LifeBar;
+
+public:
+	
+	/** Constructor */
+	ACombatEnemy();
+
+protected:
+
+	/** Max amount of HP the character will have on respawn */
+	UPROPERTY(EditAnywhere, Category="Damage")
+	float MaxHP = 3.0f;
+
+public:
+
+	/** Current amount of HP the character has */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Damage", meta = (ClampMin = 0, ClampMax = 100))
+	float CurrentHP = 0.0f;
+
+protected:
+
+	/** Name of the pelvis bone, for damage ragdoll physics */
+	UPROPERTY(EditAnywhere, Category="Damage")
+	FName PelvisBoneName;
+
+	/** Pointer to the life bar widget */
+	UPROPERTY(EditAnywhere, Category="Damage")
+	UCombatLifeBar* LifeBarWidget;
+
+	/** If true, the character is currently playing an attack animation */
+	bool bIsAttacking = false;
+
+	/** Distance ahead of the character that melee attack sphere collision traces will extend */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Trace", meta = (ClampMin = 0, ClampMax = 500, Units = "cm"))
+	float MeleeTraceDistance = 75.0f;
+
+	/** Radius of the sphere trace for melee attacks */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Trace", meta = (ClampMin = 0, ClampMax = 500, Units = "cm"))
+	float MeleeTraceRadius = 50.0f;
+
+	/** Amount of damage a melee attack will deal */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Damage", meta = (ClampMin = 0, ClampMax = 100))
+	float MeleeDamage = 1.0f;
+
+	/** Amount of knockback impulse a melee attack will apply */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Damage", meta = (ClampMin = 0, ClampMax = 1000, Units = "cm/s"))
+	float MeleeKnockbackImpulse = 150.0f;
+
+	/** Amount of upwards impulse a melee attack will apply */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Damage", meta = (ClampMin = 0, ClampMax = 1000, Units = "cm/s"))
+	float MeleeLaunchImpulse = 350.0f;
+
+	/** AnimMontage that will play for combo attacks */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Combo")
+	UAnimMontage* ComboAttackMontage;
+
+	/** Names of the AnimMontage sections that correspond to each stage of the combo attack */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Combo")
+	TArray<FName> ComboSectionNames;
+
+	/** Target number of attacks in the combo attack string we're playing */
+	int32 TargetComboCount = 0;
+
+	/** Index of the current stage of the melee attack combo */
+	int32 CurrentComboAttack = 0;
+
+	/** AnimMontage that will play for charged attacks */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Charged")
+	UAnimMontage* ChargedAttackMontage;
+
+	/** Name of the AnimMontage section that corresponds to the charge loop */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Charged")
+	FName ChargeLoopSection;
+
+	/** Name of the AnimMontage section that corresponds to the attack */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Charged")
+	FName ChargeAttackSection;
+
+	/** Minimum number of charge animation loops that will be played by the AI */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Charged", meta = (ClampMin = 1, ClampMax = 20))
+	int32 MinChargeLoops = 2;
+
+	/** Maximum number of charge animation loops that will be played by the AI */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Charged", meta = (ClampMin = 1, ClampMax = 20))
+	int32 MaxChargeLoops = 5;
+
+	/** Target number of charge animation loops to play in this charged attack */
+	int32 TargetChargeLoops = 0;
+
+	/** Number of charge animation loop currently playing */
+	int32 CurrentChargeLoop = 0;
+
+	/** Time to wait before removing this character from the level after it dies */
+	UPROPERTY(EditAnywhere, Category="Death")
+	float DeathRemovalTime = 5.0f;
+
+	/** Enemy death timer */
+	FTimerHandle DeathTimer;
+
+	/** Attack montage ended delegate */
+	FOnMontageEnded OnAttackMontageEnded;
+
+	/** Last recorded location we're being attacked from */
+	FVector LastDangerLocation = FVector::ZeroVector;
+
+	/** Last recorded game time we were attacked */
+	float LastDangerTime = -1000.0f;
+
+public:
+	/** Attack completed internal delegate to notify StateTree tasks */
+	FOnEnemyAttackCompleted OnAttackCompleted;
+
+	/** Landed internal delegate to notify StateTree tasks. We use this instead of the built-in Landed delegate so we can bind to a Lambda in StateTree tasks */
+	FOnEnemyLanded OnEnemyLanded;
+
+	/** Enemy died delegate. Allows external subscribers to respond to enemy death */
+	UPROPERTY(BlueprintAssignable, Category="Events")
+	FOnEnemyDied OnEnemyDied;
+
+public:
+
+	/** Performs an AI-initiated combo attack. Number of hits will be decided by this character */
+	void DoAIComboAttack();
+
+	/** Performs an AI-initiated charged attack. Charge time will be decided by this character */
+	void DoAIChargedAttack();
+
+	/** Called from a delegate when the attack montage ends */
+	void AttackMontageEnded(UAnimMontage* Montage, bool bInterrupted);
+
+	/** Returns the last recorded location we were attacked from */
+	const FVector& GetLastDangerLocation() const;
+
+	/** Returns the last game time we were attacked */
+	float GetLastDangerTime() const;
+
+public:
+
+	// ~begin ICombatAttacker interface
+
+	/** Performs an attack's collision check */
+	virtual void DoAttackTrace(FName DamageSourceBone) override;
+
+	/** Performs a combo attack's check to continue the string */
+	UFUNCTION(BlueprintCallable, Category="Attacker")
+	virtual void CheckCombo() override;
+
+	/** Performs a charged attack's check to loop the charge animation */
+	UFUNCTION(BlueprintCallable, Category="Attacker")
+	virtual void CheckChargedAttack() override;
+
+	// ~end ICombatAttacker interface
+
+	// ~begin ICombatDamageable interface
+
+	/** Handles damage and knockback events */
+	virtual void ApplyDamage(float Damage, AActor* DamageCauser, const FVector& DamageLocation, const FVector& DamageImpulse) override;
+
+	/** Handles death events */
+	virtual void HandleDeath() override;
+
+	/** Handles healing events */
+	virtual void ApplyHealing(float Healing, AActor* Healer) override;
+
+	/** Allows the enemy to react to incoming attacks */
+	virtual void NotifyDanger(const FVector& DangerLocation, AActor* DangerSource) override;
+
+	// ~end ICombatDamageable interface
+
+protected:
+
+	/** Removes this character from the level after it dies */
+	void RemoveFromLevel();
+
+public:
+
+	/** Overrides the default TakeDamage functionality */
+	virtual float TakeDamage(float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser) override;
+
+	/** Overrides landing to reset damage ragdoll physics */
+	virtual void Landed(const FHitResult& Hit) override;
+
+protected:
+
+	/** Blueprint handler to play damage received effects */
+	UFUNCTION(BlueprintImplementableEvent, Category="Combat")
+	void ReceivedDamage(float Damage, const FVector& ImpactPoint, const FVector& DamageDirection);
+
+protected:
+
+	/** Gameplay initialization */
+	virtual void BeginPlay() override;
+
+	/** EndPlay cleanup */
+	virtual void EndPlay(EEndPlayReason::Type EndPlayReason) override;
+};

Source/Pockmon/Variant_Combat/AI/CombatEnemySpawner.cpp

@@ -0,0 +1,126 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatEnemySpawner.h"
+#include "Engine/World.h"
+#include "Components/SceneComponent.h"
+#include "Components/CapsuleComponent.h"
+#include "Components/ArrowComponent.h"
+#include "TimerManager.h"
+#include "CombatEnemy.h"
+
+ACombatEnemySpawner::ACombatEnemySpawner()
+{
+	PrimaryActorTick.bCanEverTick = false;
+
+	// create the root
+	RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
+
+	// create the reference spawn capsule
+	SpawnCapsule = CreateDefaultSubobject<UCapsuleComponent>(TEXT("Spawn Capsule"));
+	SpawnCapsule->SetupAttachment(RootComponent);
+
+	SpawnCapsule->SetRelativeLocation(FVector(0.0f, 0.0f, 90.0f));
+	SpawnCapsule->SetCapsuleSize(35.0f, 90.0f);
+	SpawnCapsule->SetCollisionProfileName(FName("NoCollision"));
+
+	SpawnDirection = CreateDefaultSubobject<UArrowComponent>(TEXT("Spawn Direction"));
+	SpawnDirection->SetupAttachment(RootComponent);
+}
+
+void ACombatEnemySpawner::BeginPlay()
+{
+	Super::BeginPlay();
+	
+	// should we spawn an enemy right away?
+	if (bShouldSpawnEnemiesImmediately)
+	{
+		// schedule the first enemy spawn
+		GetWorld()->GetTimerManager().SetTimer(SpawnTimer, this, &ACombatEnemySpawner::SpawnEnemy, InitialSpawnDelay);
+	}
+
+}
+
+void ACombatEnemySpawner::EndPlay(EEndPlayReason::Type EndPlayReason)
+{
+	Super::EndPlay(EndPlayReason);
+
+	// clear the spawn timer
+	GetWorld()->GetTimerManager().ClearTimer(SpawnTimer);
+}
+
+void ACombatEnemySpawner::SpawnEnemy()
+{
+	// ensure the enemy class is valid
+	if (IsValid(EnemyClass))
+	{
+		// spawn the enemy at the reference capsule's transform
+		FActorSpawnParameters SpawnParams;
+		SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;
+
+		ACombatEnemy* SpawnedEnemy = GetWorld()->SpawnActor<ACombatEnemy>(EnemyClass, SpawnCapsule->GetComponentTransform(), SpawnParams);
+
+		// was the enemy successfully created?
+		if (SpawnedEnemy)
+		{
+			// subscribe to the death delegate
+			SpawnedEnemy->OnEnemyDied.AddDynamic(this, &ACombatEnemySpawner::OnEnemyDied);
+		}
+	}
+}
+
+void ACombatEnemySpawner::OnEnemyDied()
+{
+	// decrease the spawn counter
+	--SpawnCount;
+
+	// is this the last enemy we should spawn?
+	if (SpawnCount <= 0)
+	{
+		// schedule the activation on depleted message
+		GetWorld()->GetTimerManager().SetTimer(SpawnTimer, this, &ACombatEnemySpawner::SpawnerDepleted, ActivationDelay);
+		return;
+	}
+
+	// schedule the next enemy spawn
+	GetWorld()->GetTimerManager().SetTimer(SpawnTimer, this, &ACombatEnemySpawner::SpawnEnemy, RespawnDelay);
+}
+
+void ACombatEnemySpawner::SpawnerDepleted()
+{
+	// process the actors to activate list
+	for (AActor* CurrentActor : ActorsToActivateWhenDepleted)
+	{
+		// check if the actor is activatable
+		if (ICombatActivatable* CombatActivatable = Cast<ICombatActivatable>(CurrentActor))
+		{
+			// activate the actor
+			CombatActivatable->ActivateInteraction(this);
+		}
+	}
+}
+
+void ACombatEnemySpawner::ToggleInteraction(AActor* ActivationInstigator)
+{
+	// stub
+}
+
+void ACombatEnemySpawner::ActivateInteraction(AActor* ActivationInstigator)
+{
+	// ensure we're only activated once, and only if we've deferred enemy spawning
+	if (bHasBeenActivated || bShouldSpawnEnemiesImmediately)
+	{
+		return;
+	}
+
+	// raise the activation flag
+	bHasBeenActivated = true;
+
+	// spawn the first enemy
+	SpawnEnemy();
+}
+
+void ACombatEnemySpawner::DeactivateInteraction(AActor* ActivationInstigator)
+{
+	// stub
+}

Source/Pockmon/Variant_Combat/AI/CombatEnemySpawner.h

@@ -0,0 +1,109 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "CombatActivatable.h"
+#include "CombatEnemySpawner.generated.h"
+
+class UCapsuleComponent;
+class UArrowComponent;
+class ACombatEnemy;
+
+/**
+ *  A basic Actor in charge of spawning Enemy Characters and monitoring their deaths.
+ *  Enemies will be spawned one by one, and the spawner will wait until the enemy dies before spawning a new one.
+ *  The spawner can be remotely activated through the ICombatActivatable interface
+ *  When the last spawned enemy dies, the spawner can also activate other ICombatActivatables
+ */
+UCLASS(abstract)
+class ACombatEnemySpawner : public AActor, public ICombatActivatable
+{
+	GENERATED_BODY()
+	
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components", meta = (AllowPrivateAccess = "true"))
+	UCapsuleComponent* SpawnCapsule;
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components", meta = (AllowPrivateAccess = "true"))
+	UArrowComponent* SpawnDirection;
+
+protected:
+
+	/** Type of enemy to spawn */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Enemy Spawner")
+	TSubclassOf<ACombatEnemy> EnemyClass;
+
+	/** If true, the first enemy will be spawned as soon as the game starts */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Enemy Spawner")
+	bool bShouldSpawnEnemiesImmediately = true;
+
+	/** Time to wait before spawning the first enemy on game start */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Enemy Spawner", meta = (ClampMin = 0, ClampMax = 10))
+	float InitialSpawnDelay = 5.0f;
+
+	/** Number of enemies to spawn */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Enemy Spawner", meta = (ClampMin = 0, ClampMax = 100))
+	int32 SpawnCount = 1;
+
+	/** Time to wait before spawning the next enemy after the current one dies */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Enemy Spawner", meta = (ClampMin = 0, ClampMax = 10))
+	float RespawnDelay = 5.0f;
+
+	/** Time to wait after this spawner is depleted before activating the actor list */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Activation", meta = (ClampMin = 0, ClampMax = 10))
+	float ActivationDelay = 1.0f;
+
+	/** List of actors to activate after the last enemy dies */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Activation")
+	TArray<AActor*> ActorsToActivateWhenDepleted;
+
+	/** Flag to ensure this is only activated once */
+	bool bHasBeenActivated = false;
+
+	/** Timer to spawn enemies after a delay */
+	FTimerHandle SpawnTimer;
+
+public:	
+	
+	/** Constructor */
+	ACombatEnemySpawner();
+
+public:
+
+	/** Initialization */
+	virtual void BeginPlay() override;
+
+	/** Cleanup */
+	virtual void EndPlay(EEndPlayReason::Type EndPlayReason) override;
+
+protected:
+
+	/** Spawn an enemy and subscribe to its death event */
+	void SpawnEnemy();
+
+	/** Called when the spawned enemy has died */
+	UFUNCTION()
+	void OnEnemyDied();
+
+	/** Called after the last spawned enemy has died */
+	void SpawnerDepleted();
+
+public:
+
+	// ~begin ICombatActivatable interface
+
+	/** Toggles the Spawner */
+	UFUNCTION(BlueprintCallable, Category="Activatable")
+	virtual void ToggleInteraction(AActor* ActivationInstigator) override;
+
+	/** Activates the Spawner */
+	UFUNCTION(BlueprintCallable, Category="Activatable")
+	virtual void ActivateInteraction(AActor* ActivationInstigator) override;
+
+	/** Deactivates the Spawner */
+	UFUNCTION(BlueprintCallable, Category="Activatable")
+	virtual void DeactivateInteraction(AActor* ActivationInstigator) override;
+
+	// ~end IActivatable interface
+};

Source/Pockmon/Variant_Combat/AI/CombatStateTreeUtility.cpp

@@ -0,0 +1,325 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatStateTreeUtility.h"
+#include "StateTreeExecutionContext.h"
+#include "StateTreeExecutionTypes.h"
+#include "Engine/World.h"
+#include "GameFramework/Character.h"
+#include "GameFramework/CharacterMovementComponent.h"
+#include "AIController.h"
+#include "CombatEnemy.h"
+#include "Kismet/GameplayStatics.h"
+#include "StateTreeAsyncExecutionContext.h"
+
+bool FStateTreeCharacterGroundedCondition::TestCondition(FStateTreeExecutionContext& Context) const
+{
+	const FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+	// is the character currently grounded?
+	bool bCondition = InstanceData.Character->GetMovementComponent()->IsMovingOnGround();
+
+	return InstanceData.bMustBeOnAir ? !bCondition : bCondition;
+}
+
+#if WITH_EDITOR
+FText FStateTreeCharacterGroundedCondition::GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting /*= EStateTreeNodeFormatting::Text*/) const
+{
+	return FText::FromString("<b>Is Character Grounded</b>");
+}
+#endif // WITH_EDITOR
+
+////////////////////////////////////////////////////////////////////
+
+bool FStateTreeIsInDangerCondition::TestCondition(FStateTreeExecutionContext& Context) const
+{
+	const FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+	// ensure we have a valid enemy character
+	if (InstanceData.Character)
+	{
+		// is the last detected danger event within the reaction threshold?
+		const float ReactionDelta = InstanceData.Character->GetWorld()->GetTimeSeconds() - InstanceData.Character->GetLastDangerTime();
+
+		if (ReactionDelta < InstanceData.MaxReactionTime && ReactionDelta > InstanceData.MinReactionTime)
+		{
+			// do a dot product check to determine if the danger location is within the character's detection cone
+			const FVector DangerDir = (InstanceData.Character->GetLastDangerLocation() - InstanceData.Character->GetActorLocation()).GetSafeNormal2D();
+
+			const float DangerDot = FVector::DotProduct(DangerDir, InstanceData.Character->GetActorForwardVector());
+			const float ConeAngleCos = FMath::Cos(FMath::DegreesToRadians(InstanceData.DangerSightConeAngle));
+
+			return DangerDot > ConeAngleCos;
+		}
+	}
+
+	return false;
+}
+
+#if WITH_EDITOR
+FText FStateTreeIsInDangerCondition::GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting /*= EStateTreeNodeFormatting::Text*/) const
+{
+	return FText::FromString("<b>Is Character In Danger</b>");
+}
+#endif // WITH_EDITOR
+
+////////////////////////////////////////////////////////////////////
+
+EStateTreeRunStatus FStateTreeComboAttackTask::EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const
+{
+	// have we transitioned from another state?
+	if (Transition.ChangeType == EStateTreeStateChangeType::Changed)
+	{
+		// get the instance data
+		FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+		// bind to the on attack completed delegate
+		InstanceData.Character->OnAttackCompleted.BindLambda(
+			[WeakContext = Context.MakeWeakExecutionContext()]()
+			{
+				WeakContext.FinishTask(EStateTreeFinishTaskType::Succeeded);
+			}
+		);
+
+
+		// tell the character to do a combo attack
+		InstanceData.Character->DoAIComboAttack();
+	}
+
+	return EStateTreeRunStatus::Running;
+}
+
+void FStateTreeComboAttackTask::ExitState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const
+{
+	// have we transitioned from another state?
+	if (Transition.ChangeType == EStateTreeStateChangeType::Changed)
+	{
+		// get the instance data
+		FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+		// unbind the on attack completed delegate
+		InstanceData.Character->OnAttackCompleted.Unbind();
+	}
+}
+
+#if WITH_EDITOR
+FText FStateTreeComboAttackTask::GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting /*= EStateTreeNodeFormatting::Text*/) const
+{
+	return FText::FromString("<b>Do Combo Attack</b>");
+}
+#endif // WITH_EDITOR
+
+////////////////////////////////////////////////////////////////////
+
+EStateTreeRunStatus FStateTreeChargedAttackTask::EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const
+{
+	// have we transitioned from another state?
+	if (Transition.ChangeType == EStateTreeStateChangeType::Changed)
+	{
+		// get the instance data
+		FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+		// bind to the on attack completed delegate
+		InstanceData.Character->OnAttackCompleted.BindLambda(
+			[WeakContext = Context.MakeWeakExecutionContext()]()
+			{
+				WeakContext.FinishTask(EStateTreeFinishTaskType::Succeeded);
+			}
+		);
+
+		// tell the character to do a charged attack
+		InstanceData.Character->DoAIChargedAttack();
+	}
+
+	return EStateTreeRunStatus::Running;
+}
+
+void FStateTreeChargedAttackTask::ExitState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const
+{
+	// have we transitioned from another state?
+	if (Transition.ChangeType == EStateTreeStateChangeType::Changed)
+	{
+		// get the instance data
+		FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+		// unbind the on attack completed delegate
+		InstanceData.Character->OnAttackCompleted.Unbind();
+	}
+}
+
+#if WITH_EDITOR
+FText FStateTreeChargedAttackTask::GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting /*= EStateTreeNodeFormatting::Text*/) const
+{
+	return FText::FromString("<b>Do Charged Attack</b>");
+}
+#endif // WITH_EDITOR
+
+////////////////////////////////////////////////////////////////////
+
+EStateTreeRunStatus FStateTreeWaitForLandingTask::EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const
+{
+	// have we transitioned from another state?
+	if (Transition.ChangeType == EStateTreeStateChangeType::Changed)
+	{
+		// get the instance data
+		FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+		// bind to the on enemy landed delegate
+		InstanceData.Character->OnEnemyLanded.BindLambda(
+			[WeakContext = Context.MakeWeakExecutionContext()]()
+			{
+				WeakContext.FinishTask(EStateTreeFinishTaskType::Succeeded);
+			}
+		);
+	}
+
+	return EStateTreeRunStatus::Running;
+}
+
+void FStateTreeWaitForLandingTask::ExitState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const
+{
+	// have we transitioned from another state?
+	if (Transition.ChangeType == EStateTreeStateChangeType::Changed)
+	{
+		// get the instance data
+		FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+		// unbind the on enemy landed delegate
+		InstanceData.Character->OnEnemyLanded.Unbind();
+	}
+}
+
+#if WITH_EDITOR
+FText FStateTreeWaitForLandingTask::GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting /*= EStateTreeNodeFormatting::Text*/) const
+{
+	return FText::FromString("<b>Wait for Landing</b>");
+}
+#endif // WITH_EDITOR
+
+////////////////////////////////////////////////////////////////////
+
+EStateTreeRunStatus FStateTreeFaceActorTask::EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const
+{
+	// have we transitioned from another state?
+	if (Transition.ChangeType == EStateTreeStateChangeType::Changed)
+	{
+		// get the instance data
+		FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+		// set the AI Controller's focus
+		InstanceData.Controller->SetFocus(InstanceData.ActorToFaceTowards);
+	}
+
+	return EStateTreeRunStatus::Running;
+}
+
+void FStateTreeFaceActorTask::ExitState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const
+{
+	// have we transitioned to another state?
+	if (Transition.ChangeType == EStateTreeStateChangeType::Changed)
+	{
+		// get the instance data
+		FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+		// clear the AI Controller's focus
+		InstanceData.Controller->ClearFocus(EAIFocusPriority::Gameplay);
+	}
+}
+
+#if WITH_EDITOR
+FText FStateTreeFaceActorTask::GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting /*= EStateTreeNodeFormatting::Text*/) const
+{
+	return FText::FromString("<b>Face Towards Actor</b>");
+}
+#endif // WITH_EDITOR
+
+////////////////////////////////////////////////////////////////////
+
+EStateTreeRunStatus FStateTreeFaceLocationTask::EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const
+{
+	// have we transitioned from another state?
+	if (Transition.ChangeType == EStateTreeStateChangeType::Changed)
+	{
+		// get the instance data
+		FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+		// set the AI Controller's focus
+		InstanceData.Controller->SetFocalPoint(InstanceData.FaceLocation);
+	}
+
+	return EStateTreeRunStatus::Running;
+}
+
+void FStateTreeFaceLocationTask::ExitState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const
+{
+	// have we transitioned to another state?
+	if (Transition.ChangeType == EStateTreeStateChangeType::Changed)
+	{
+		// get the instance data
+		FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+		// clear the AI Controller's focus
+		InstanceData.Controller->ClearFocus(EAIFocusPriority::Gameplay);
+	}
+}
+
+#if WITH_EDITOR
+FText FStateTreeFaceLocationTask::GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting /*= EStateTreeNodeFormatting::Text*/) const
+{
+	return FText::FromString("<b>Face Towards Location</b>");
+}
+#endif // WITH_EDITOR
+
+////////////////////////////////////////////////////////////////////
+
+EStateTreeRunStatus FStateTreeSetCharacterSpeedTask::EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const
+{
+	// have we transitioned from another state?
+	if (Transition.ChangeType == EStateTreeStateChangeType::Changed)
+	{
+		// get the instance data
+		FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+		// set the character's max ground speed
+		InstanceData.Character->GetCharacterMovement()->MaxWalkSpeed = InstanceData.Speed;
+	}
+
+	return EStateTreeRunStatus::Running;
+}
+
+#if WITH_EDITOR
+FText FStateTreeSetCharacterSpeedTask::GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting /*= EStateTreeNodeFormatting::Text*/) const
+{
+	return FText::FromString("<b>Set Character Speed</b>");
+}
+#endif // WITH_EDITOR
+
+////////////////////////////////////////////////////////////////////
+
+EStateTreeRunStatus FStateTreeGetPlayerInfoTask::Tick(FStateTreeExecutionContext& Context, const float DeltaTime) const
+{
+	// get the instance data
+	FInstanceDataType& InstanceData = Context.GetInstanceData(*this);
+
+	// get the character possessed by the first local player
+	InstanceData.TargetPlayerCharacter = Cast<ACharacter>(UGameplayStatics::GetPlayerPawn(InstanceData.Character, 0));
+
+	// do we have a valid target?
+	if (InstanceData.TargetPlayerCharacter)
+	{
+		// update the last known location
+		InstanceData.TargetPlayerLocation = InstanceData.TargetPlayerCharacter->GetActorLocation();
+	}
+
+	// update the distance
+	InstanceData.DistanceToTarget = FVector::Distance(InstanceData.TargetPlayerLocation, InstanceData.Character->GetActorLocation());
+
+	return EStateTreeRunStatus::Running;
+}
+
+#if WITH_EDITOR
+FText FStateTreeGetPlayerInfoTask::GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting /*= EStateTreeNodeFormatting::Text*/) const
+{
+	return FText::FromString("<b>Get Player Info</b>");
+}
+#endif // WITH_EDITOR

Source/Pockmon/Variant_Combat/AI/CombatStateTreeUtility.h

@@ -0,0 +1,365 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "StateTreeTaskBase.h"
+#include "StateTreeConditionBase.h"
+
+#include "CombatStateTreeUtility.generated.h"
+
+class ACharacter;
+class AAIController;
+class ACombatEnemy;
+
+/**
+ *  Instance data struct for the FStateTreeCharacterGroundedCondition condition
+ */
+USTRUCT()
+struct FStateTreeCharacterGroundedConditionInstanceData
+{
+	GENERATED_BODY()
+	
+	/** Character to check grounded status on */
+	UPROPERTY(EditAnywhere, Category = "Context")
+	ACharacter* Character;
+
+	/** If true, the condition passes if the character is not grounded instead */
+	UPROPERTY(EditAnywhere, Category = "Condition")
+	bool bMustBeOnAir = false;
+};
+STATETREE_POD_INSTANCEDATA(FStateTreeCharacterGroundedConditionInstanceData);
+
+/**
+ *  StateTree condition to check if the character is grounded
+ */
+USTRUCT(DisplayName = "Character is Grounded")
+struct FStateTreeCharacterGroundedCondition : public FStateTreeConditionCommonBase
+{
+	GENERATED_BODY()
+
+	/** Set the instance data type */
+	using FInstanceDataType = FStateTreeCharacterGroundedConditionInstanceData;
+	virtual const UStruct* GetInstanceDataType() const override { return FInstanceDataType::StaticStruct(); }
+
+	/** Default constructor */
+	FStateTreeCharacterGroundedCondition() = default;
+	
+	/** Tests the StateTree condition */
+	virtual bool TestCondition(FStateTreeExecutionContext& Context) const override;
+
+#if WITH_EDITOR
+
+	/** Provides the description string */
+	virtual FText GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting = EStateTreeNodeFormatting::Text) const override;
+#endif
+
+};
+
+////////////////////////////////////////////////////////////////////
+
+/**
+ *  Instance data struct for the FStateTreeIsInDangerCondition condition
+ */
+USTRUCT()
+struct FStateTreeIsInDangerConditionInstanceData
+{
+	GENERATED_BODY()
+	
+	/** Character to check danger status on */
+	UPROPERTY(EditAnywhere, Category = "Context")
+	ACombatEnemy* Character;
+
+	/** Minimum time to wait before reacting to the danger event */
+	UPROPERTY(EditAnywhere, Category = "Parameters", meta = (Units = "s"))
+	float MinReactionTime = 0.35f;
+
+	/** Maximum time to wait before ignoring the danger event */
+	UPROPERTY(EditAnywhere, Category = "Parameters", meta = (Units = "s"))
+	float MaxReactionTime = 0.75f;
+
+	/** Line of sight half angle for detecting incoming danger, in degrees*/
+	UPROPERTY(EditAnywhere, Category = "Parameters", meta = (Units = "degrees"))
+	float DangerSightConeAngle = 120.0f;
+};
+STATETREE_POD_INSTANCEDATA(FStateTreeIsInDangerConditionInstanceData);
+
+/**
+ *  StateTree condition to check if the character is about to be hit by an attack
+ */
+USTRUCT(DisplayName = "Character is in Danger")
+struct FStateTreeIsInDangerCondition : public FStateTreeConditionCommonBase
+{
+	GENERATED_BODY()
+
+	/** Set the instance data type */
+	using FInstanceDataType = FStateTreeIsInDangerConditionInstanceData;
+	virtual const UStruct* GetInstanceDataType() const override { return FInstanceDataType::StaticStruct(); }
+
+	/** Default constructor */
+	FStateTreeIsInDangerCondition() = default;
+	
+	/** Tests the StateTree condition */
+	virtual bool TestCondition(FStateTreeExecutionContext& Context) const override;
+
+#if WITH_EDITOR
+
+	/** Provides the description string */
+	virtual FText GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting = EStateTreeNodeFormatting::Text) const override;
+#endif
+
+};
+
+////////////////////////////////////////////////////////////////////
+
+/**
+ *  Instance data struct for the Combat StateTree tasks
+ */
+USTRUCT()
+struct FStateTreeAttackInstanceData
+{
+	GENERATED_BODY()
+
+	/** Character that will perform the attack */
+	UPROPERTY(EditAnywhere, Category = Context)
+	TObjectPtr<ACombatEnemy> Character;
+};
+
+/**
+ *  StateTree task to perform a combo attack
+ */
+USTRUCT(meta=(DisplayName="Combo Attack", Category="Combat"))
+struct FStateTreeComboAttackTask : public FStateTreeTaskCommonBase
+{
+	GENERATED_BODY()
+
+	/* Ensure we're using the correct instance data struct */
+	using FInstanceDataType = FStateTreeAttackInstanceData;
+	virtual const UStruct* GetInstanceDataType() const override { return FInstanceDataType::StaticStruct(); }
+
+	/** Runs when the owning state is entered */
+	virtual EStateTreeRunStatus EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const override;
+
+	/** Runs when the owning state is ended */
+	virtual void ExitState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const override;
+
+#if WITH_EDITOR
+	virtual FText GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting = EStateTreeNodeFormatting::Text) const override;
+#endif // WITH_EDITOR
+};
+
+/**
+ *  StateTree task to perform a charged attack
+ */
+USTRUCT(meta=(DisplayName="Charged Attack", Category="Combat"))
+struct FStateTreeChargedAttackTask : public FStateTreeTaskCommonBase
+{
+	GENERATED_BODY()
+
+	/* Ensure we're using the correct instance data struct */
+	using FInstanceDataType = FStateTreeAttackInstanceData;
+	virtual const UStruct* GetInstanceDataType() const override { return FInstanceDataType::StaticStruct(); }
+
+	/** Runs when the owning state is entered */
+	virtual EStateTreeRunStatus EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const override;
+
+	/** Runs when the owning state is ended */
+	virtual void ExitState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const override;
+
+#if WITH_EDITOR
+	virtual FText GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting = EStateTreeNodeFormatting::Text) const override;
+#endif // WITH_EDITOR
+};
+
+/**
+ *  StateTree task to wait for the character to land
+ */
+USTRUCT(meta=(DisplayName="Wait for Landing", Category="Combat"))
+struct FStateTreeWaitForLandingTask : public FStateTreeTaskCommonBase
+{
+	GENERATED_BODY()
+
+	/* Ensure we're using the correct instance data struct */
+	using FInstanceDataType = FStateTreeAttackInstanceData;
+	virtual const UStruct* GetInstanceDataType() const override { return FInstanceDataType::StaticStruct(); }
+
+	/** Runs when the owning state is entered */
+	virtual EStateTreeRunStatus EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const override;
+
+	/** Runs when the owning state is ended */
+	virtual void ExitState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const override;
+
+#if WITH_EDITOR
+	virtual FText GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting = EStateTreeNodeFormatting::Text) const override;
+#endif // WITH_EDITOR
+};
+
+////////////////////////////////////////////////////////////////////
+
+/**
+ *  Instance data struct for the Face Towards Actor StateTree task
+ */
+USTRUCT()
+struct FStateTreeFaceActorInstanceData
+{
+	GENERATED_BODY()
+
+	/** AI Controller that will determine the focused actor */
+	UPROPERTY(EditAnywhere, Category = Context)
+	TObjectPtr<AAIController> Controller;
+
+	/** Actor that will be faced towards */
+	UPROPERTY(EditAnywhere, Category = Input)
+	TObjectPtr<AActor> ActorToFaceTowards;
+};
+
+/**
+ *  StateTree task to face an AI-Controlled Pawn towards an Actor
+ */
+USTRUCT(meta=(DisplayName="Face Towards Actor", Category="Combat"))
+struct FStateTreeFaceActorTask : public FStateTreeTaskCommonBase
+{
+	GENERATED_BODY()
+
+	/* Ensure we're using the correct instance data struct */
+	using FInstanceDataType = FStateTreeFaceActorInstanceData;
+	virtual const UStruct* GetInstanceDataType() const override { return FInstanceDataType::StaticStruct(); }
+
+	/** Runs when the owning state is entered */
+	virtual EStateTreeRunStatus EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const override;
+
+	/** Runs when the owning state is ended */
+	virtual void ExitState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const override;
+
+#if WITH_EDITOR
+	virtual FText GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting = EStateTreeNodeFormatting::Text) const override;
+#endif // WITH_EDITOR
+};
+
+////////////////////////////////////////////////////////////////////
+
+/**
+ *  Instance data struct for the Face Towards Location StateTree task
+ */
+USTRUCT()
+struct FStateTreeFaceLocationInstanceData
+{
+	GENERATED_BODY()
+
+	/** AI Controller that will determine the focused location */
+	UPROPERTY(EditAnywhere, Category = Context)
+	TObjectPtr<AAIController> Controller;
+
+	/** Location that will be faced towards */
+	UPROPERTY(EditAnywhere, Category = Parameter)
+	FVector FaceLocation = FVector::ZeroVector;
+};
+
+/**
+ *  StateTree task to face an AI-Controlled Pawn towards a world location
+ */
+USTRUCT(meta=(DisplayName="Face Towards Location", Category="Combat"))
+struct FStateTreeFaceLocationTask : public FStateTreeTaskCommonBase
+{
+	GENERATED_BODY()
+
+	/* Ensure we're using the correct instance data struct */
+	using FInstanceDataType = FStateTreeFaceLocationInstanceData;
+	virtual const UStruct* GetInstanceDataType() const override { return FInstanceDataType::StaticStruct(); }
+
+	/** Runs when the owning state is entered */
+	virtual EStateTreeRunStatus EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const override;
+
+	/** Runs when the owning state is ended */
+	virtual void ExitState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const override;
+
+#if WITH_EDITOR
+	virtual FText GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting = EStateTreeNodeFormatting::Text) const override;
+#endif // WITH_EDITOR
+};
+
+////////////////////////////////////////////////////////////////////
+
+/**
+ *  Instance data struct for the Set Character Speed StateTree task
+ */
+USTRUCT()
+struct FStateTreeSetCharacterSpeedInstanceData
+{
+	GENERATED_BODY()
+
+	/** Character that will be affected */
+	UPROPERTY(EditAnywhere, Category = Context)
+	TObjectPtr<ACharacter> Character;
+
+	/** Max ground speed to set for the character */
+	UPROPERTY(EditAnywhere, Category = Parameter)
+	float Speed = 600.0f;
+};
+
+/**
+ *  StateTree task to change a Character's ground speed
+ */
+USTRUCT(meta=(DisplayName="Set Character Speed", Category="Combat"))
+struct FStateTreeSetCharacterSpeedTask : public FStateTreeTaskCommonBase
+{
+	GENERATED_BODY()
+
+	/* Ensure we're using the correct instance data struct */
+	using FInstanceDataType = FStateTreeSetCharacterSpeedInstanceData;
+	virtual const UStruct* GetInstanceDataType() const override { return FInstanceDataType::StaticStruct(); }
+
+	/** Runs when the owning state is entered */
+	virtual EStateTreeRunStatus EnterState(FStateTreeExecutionContext& Context, const FStateTreeTransitionResult& Transition) const override;
+
+#if WITH_EDITOR
+	virtual FText GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting = EStateTreeNodeFormatting::Text) const override;
+#endif // WITH_EDITOR
+};
+
+////////////////////////////////////////////////////////////////////
+
+/**
+ *  Instance data struct for the Get Player Info task
+ */
+USTRUCT()
+struct FStateTreeGetPlayerInfoInstanceData
+{
+	GENERATED_BODY()
+
+	/** Character that owns this task */
+	UPROPERTY(EditAnywhere, Category = Context)
+	TObjectPtr<ACharacter> Character;
+
+	/** Character that owns this task */
+	UPROPERTY(VisibleAnywhere)
+	TObjectPtr<ACharacter> TargetPlayerCharacter;
+
+	/** Last known location for the target */
+	UPROPERTY(VisibleAnywhere)
+	FVector TargetPlayerLocation = FVector::ZeroVector;
+
+	/** Distance to the target */
+	UPROPERTY(VisibleAnywhere)
+	float DistanceToTarget = 0.0f;
+};
+
+/**
+ *  StateTree task to get information about the player character
+ */
+USTRUCT(meta=(DisplayName="GetPlayerInfo", Category="Combat"))
+struct FStateTreeGetPlayerInfoTask : public FStateTreeTaskCommonBase
+{
+	GENERATED_BODY()
+
+	/* Ensure we're using the correct instance data struct */
+	using FInstanceDataType = FStateTreeGetPlayerInfoInstanceData;
+	virtual const UStruct* GetInstanceDataType() const override { return FInstanceDataType::StaticStruct(); }
+
+	/** Runs while the owning state is active */
+	virtual EStateTreeRunStatus Tick(FStateTreeExecutionContext& Context, const float DeltaTime) const override;
+
+#if WITH_EDITOR
+	virtual FText GetDescription(const FGuid& ID, FStateTreeDataView InstanceDataView, const IStateTreeBindingLookup& BindingLookup, EStateTreeNodeFormatting Formatting = EStateTreeNodeFormatting::Text) const override;
+#endif // WITH_EDITOR
+};

Source/Pockmon/Variant_Combat/AI/EnvQueryContext_Danger.cpp

@@ -0,0 +1,17 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "Variant_Combat/AI/EnvQueryContext_Danger.h"
+#include "Variant_Combat/AI/CombatEnemy.h"
+#include "EnvironmentQuery/EnvQueryTypes.h"
+#include "EnvironmentQuery/Items/EnvQueryItemType_Point.h"
+
+void UEnvQueryContext_Danger::ProvideContext(FEnvQueryInstance& QueryInstance, FEnvQueryContextData& ContextData) const
+{
+	// get the querying enemy
+	if (ACombatEnemy* QuerierActor = Cast<ACombatEnemy>(QueryInstance.Owner.Get()))
+	{
+		// add the last recorded danger location to the context
+		UEnvQueryItemType_Point::SetContextHelper(ContextData, QuerierActor->GetLastDangerLocation());
+	}
+}

Source/Pockmon/Variant_Combat/AI/EnvQueryContext_Danger.h

@@ -0,0 +1,23 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "EnvironmentQuery/EnvQueryContext.h"
+#include "EnvQueryContext_Danger.generated.h"
+
+/**
+ *  UEnvQueryContext_Danger
+ *  Returns the enemy character's last known danger location
+ */
+UCLASS()
+class POCKMON_API UEnvQueryContext_Danger : public UEnvQueryContext
+{
+	GENERATED_BODY()
+	
+public:
+
+	/** Provides the context locations or actors for this EnvQuery */
+	virtual void ProvideContext(FEnvQueryInstance& QueryInstance, FEnvQueryContextData& ContextData) const override;
+
+};

Source/Pockmon/Variant_Combat/AI/EnvQueryContext_Player.cpp

@@ -0,0 +1,18 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "EnvQueryContext_Player.h"
+#include "Kismet/GameplayStatics.h"
+#include "EnvironmentQuery/EnvQueryTypes.h"
+#include "EnvironmentQuery/Items/EnvQueryItemType_Actor.h"
+#include "GameFramework/Pawn.h"
+
+void UEnvQueryContext_Player::ProvideContext(FEnvQueryInstance& QueryInstance, FEnvQueryContextData& ContextData) const
+{
+	// get the player pawn for the first local player
+	AActor* PlayerPawn = UGameplayStatics::GetPlayerPawn(QueryInstance.Owner.Get(), 0);
+	check(PlayerPawn);
+
+	// add the actor data to the context
+	UEnvQueryItemType_Actor::SetContextHelper(ContextData, PlayerPawn);
+}

Source/Pockmon/Variant_Combat/AI/EnvQueryContext_Player.h

@@ -0,0 +1,22 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "EnvironmentQuery/EnvQueryContext.h"
+#include "EnvQueryContext_Player.generated.h"
+
+/**
+ *  UEnvQueryContext_Player
+ *  Basic EnvQuery Context that returns the first local player
+ */
+UCLASS()
+class UEnvQueryContext_Player : public UEnvQueryContext
+{
+	GENERATED_BODY()
+	
+public:
+
+	/** Provides the context locations or actors for this EnvQuery */
+	virtual void ProvideContext(FEnvQueryInstance& QueryInstance, FEnvQueryContextData& ContextData) const override;
+};

Source/Pockmon/Variant_Combat/Animation/AnimNotify_CheckChargedAttack.cpp

@@ -0,0 +1,21 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "AnimNotify_CheckChargedAttack.h"
+#include "CombatAttacker.h"
+#include "Components/SkeletalMeshComponent.h"
+
+void UAnimNotify_CheckChargedAttack::Notify(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const FAnimNotifyEventReference& EventReference)
+{
+	// cast the owner to the attacker interface
+	if (ICombatAttacker* AttackerInterface = Cast<ICombatAttacker>(MeshComp->GetOwner()))
+	{
+		// tell the actor to check for a charged attack loop
+		AttackerInterface->CheckChargedAttack();
+	}
+}
+
+FString UAnimNotify_CheckChargedAttack::GetNotifyName_Implementation() const
+{
+	return FString("Check Charged Attack");
+}

Source/Pockmon/Variant_Combat/Animation/AnimNotify_CheckChargedAttack.h

@@ -0,0 +1,24 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Animation/AnimNotifies/AnimNotify.h"
+#include "AnimNotify_CheckChargedAttack.generated.h"
+
+/**
+ *  AnimNotify to perform a charged attack hold check.
+ */
+UCLASS()
+class UAnimNotify_CheckChargedAttack : public UAnimNotify
+{
+	GENERATED_BODY()
+	
+public:
+
+	/** Perform the Anim Notify */
+	virtual void Notify(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const FAnimNotifyEventReference& EventReference) override;
+
+	/** Get the notify name */
+	virtual FString GetNotifyName_Implementation() const override;
+};

Source/Pockmon/Variant_Combat/Animation/AnimNotify_CheckCombo.cpp

@@ -0,0 +1,21 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "AnimNotify_CheckCombo.h"
+#include "CombatAttacker.h"
+#include "Components/SkeletalMeshComponent.h"
+
+void UAnimNotify_CheckCombo::Notify(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const FAnimNotifyEventReference& EventReference)
+{
+	// cast the owner to the attacker interface
+	if (ICombatAttacker* AttackerInterface = Cast<ICombatAttacker>(MeshComp->GetOwner()))
+	{
+		// tell the actor to check for combo string
+		AttackerInterface->CheckCombo();
+	}
+}
+
+FString UAnimNotify_CheckCombo::GetNotifyName_Implementation() const
+{
+	return FString("Check Combo String");
+}

Source/Pockmon/Variant_Combat/Animation/AnimNotify_CheckCombo.h

@@ -0,0 +1,24 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Animation/AnimNotifies/AnimNotify.h"
+#include "AnimNotify_CheckCombo.generated.h"
+
+/**
+ *  AnimNotify to perform a combo string check.
+ */
+UCLASS()
+class UAnimNotify_CheckCombo : public UAnimNotify
+{
+	GENERATED_BODY()
+	
+public:
+
+	/** Perform the Anim Notify */
+	virtual void Notify(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const FAnimNotifyEventReference& EventReference) override;
+
+	/** Get the notify name */
+	virtual FString GetNotifyName_Implementation() const override;
+};

Source/Pockmon/Variant_Combat/Animation/AnimNotify_DoAttackTrace.cpp

@@ -0,0 +1,20 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "AnimNotify_DoAttackTrace.h"
+#include "CombatAttacker.h"
+#include "Components/SkeletalMeshComponent.h"
+
+void UAnimNotify_DoAttackTrace::Notify(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const FAnimNotifyEventReference& EventReference)
+{
+	// cast the owner to the attacker interface
+	if (ICombatAttacker* AttackerInterface = Cast<ICombatAttacker>(MeshComp->GetOwner()))
+	{
+		AttackerInterface->DoAttackTrace(AttackBoneName);
+	}
+}
+
+FString UAnimNotify_DoAttackTrace::GetNotifyName_Implementation() const
+{
+	return FString("Do Attack Trace");
+}

Source/Pockmon/Variant_Combat/Animation/AnimNotify_DoAttackTrace.h

@@ -0,0 +1,30 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Animation/AnimNotifies/AnimNotify.h"
+#include "AnimNotify_DoAttackTrace.generated.h"
+
+/**
+ *  AnimNotify to tell the actor to perform an attack trace check to look for targets to damage.
+ */
+UCLASS()
+class UAnimNotify_DoAttackTrace : public UAnimNotify
+{
+	GENERATED_BODY()
+	
+protected:
+
+	/** Source bone for the attack trace */
+	UPROPERTY(EditAnywhere, Category="Attack")
+	FName AttackBoneName;
+
+public:
+
+	/** Perform the Anim Notify */
+	virtual void Notify(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const FAnimNotifyEventReference& EventReference) override;
+
+	/** Get the notify name */
+	virtual FString GetNotifyName_Implementation() const override;
+};

Source/Pockmon/Variant_Combat/CombatCharacter.cpp

@@ -0,0 +1,547 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatCharacter.h"
+#include "Components/CapsuleComponent.h"
+#include "Components/WidgetComponent.h"
+#include "GameFramework/CharacterMovementComponent.h"
+#include "GameFramework/SpringArmComponent.h"
+#include "Components/SkeletalMeshComponent.h"
+#include "Camera/CameraComponent.h"
+#include "EnhancedInputSubsystems.h"
+#include "EnhancedInputComponent.h"
+#include "CombatLifeBar.h"
+#include "Engine/DamageEvents.h"
+#include "TimerManager.h"
+#include "Engine/LocalPlayer.h"
+#include "CombatPlayerController.h"
+
+ACombatCharacter::ACombatCharacter()
+{
+	PrimaryActorTick.bCanEverTick = true;
+
+	// bind the attack montage ended delegate
+	OnAttackMontageEnded.BindUObject(this, &ACombatCharacter::AttackMontageEnded);
+
+	// Set size for collision capsule
+	GetCapsuleComponent()->InitCapsuleSize(35.0f, 90.0f);
+
+	// Configure character movement
+	GetCharacterMovement()->MaxWalkSpeed = 400.0f;
+
+	// create the camera boom
+	CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
+	CameraBoom->SetupAttachment(RootComponent);
+
+	CameraBoom->TargetArmLength = DefaultCameraDistance;
+	CameraBoom->bUsePawnControlRotation = true;
+	CameraBoom->bEnableCameraLag = true;
+	CameraBoom->bEnableCameraRotationLag = true;
+
+	// create the orbiting camera
+	FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
+	FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName);
+	FollowCamera->bUsePawnControlRotation = false;
+
+	// create the life bar widget component
+	LifeBar = CreateDefaultSubobject<UWidgetComponent>(TEXT("LifeBar"));
+	LifeBar->SetupAttachment(RootComponent);
+
+	// set the player tag
+	Tags.Add(FName("Player"));
+}
+
+void ACombatCharacter::Move(const FInputActionValue& Value)
+{
+	// input is a Vector2D
+	FVector2D MovementVector = Value.Get<FVector2D>();
+
+	// route the input
+	DoMove(MovementVector.X, MovementVector.Y);
+}
+
+void ACombatCharacter::Look(const FInputActionValue& Value)
+{
+	FVector2D LookAxisVector = Value.Get<FVector2D>();
+
+	// route the input
+	DoLook(LookAxisVector.X, LookAxisVector.Y);
+}
+
+void ACombatCharacter::ComboAttackPressed()
+{
+	// route the input
+	DoComboAttackStart();
+}
+
+void ACombatCharacter::ChargedAttackPressed()
+{
+	// route the input
+	DoChargedAttackStart();
+}
+
+void ACombatCharacter::ChargedAttackReleased()
+{
+	// route the input
+	DoChargedAttackEnd();
+}
+
+void ACombatCharacter::ToggleCamera()
+{
+	// call the BP hook
+	BP_ToggleCamera();
+}
+
+void ACombatCharacter::DoMove(float Right, float Forward)
+{
+	if (GetController() != nullptr)
+	{
+		// find out which way is forward
+		const FRotator Rotation = GetController()->GetControlRotation();
+		const FRotator YawRotation(0, Rotation.Yaw, 0);
+
+		// get forward vector
+		const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
+
+		// get right vector 
+		const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
+
+		// add movement 
+		AddMovementInput(ForwardDirection, Forward);
+		AddMovementInput(RightDirection, Right);
+	}
+}
+
+void ACombatCharacter::DoLook(float Yaw, float Pitch)
+{
+	if (GetController() != nullptr)
+	{
+		// add yaw and pitch input to controller
+		AddControllerYawInput(Yaw);
+		AddControllerPitchInput(Pitch);
+	}
+}
+
+void ACombatCharacter::DoComboAttackStart()
+{
+	// are we already playing an attack animation?
+	if (bIsAttacking)
+	{
+		// cache the input time so we can check it later
+		CachedAttackInputTime = GetWorld()->GetTimeSeconds();
+
+		return;
+	}
+
+	// perform a combo attack
+	ComboAttack();
+}
+
+void ACombatCharacter::DoComboAttackEnd()
+{
+	// stub
+}
+
+void ACombatCharacter::DoChargedAttackStart()
+{
+	// raise the charging attack flag
+	bIsChargingAttack = true;
+
+	if (bIsAttacking)
+	{
+		// cache the input time so we can check it later
+		CachedAttackInputTime = GetWorld()->GetTimeSeconds();
+
+		return;
+	}
+
+	ChargedAttack();
+}
+
+void ACombatCharacter::DoChargedAttackEnd()
+{
+	// lower the charging attack flag
+	bIsChargingAttack = false;
+
+	// if we've done the charge loop at least once, release the charged attack right away
+	if (bHasLoopedChargedAttack)
+	{
+		CheckChargedAttack();
+	}
+}
+
+void ACombatCharacter::ResetHP()
+{
+	// reset the current HP total
+	CurrentHP = MaxHP;
+
+	// update the life bar
+	LifeBarWidget->SetLifePercentage(1.0f);
+}
+
+void ACombatCharacter::ComboAttack()
+{
+	// raise the attacking flag
+	bIsAttacking = true;
+
+	// reset the combo count
+	ComboCount = 0;
+
+	// notify enemies they are about to be attacked
+	NotifyEnemiesOfIncomingAttack();
+
+	// play the attack montage
+	if (UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance())
+	{
+		const float MontageLength = AnimInstance->Montage_Play(ComboAttackMontage, 1.0f, EMontagePlayReturnType::MontageLength, 0.0f, true);
+
+		// subscribe to montage completed and interrupted events
+		if (MontageLength > 0.0f)
+		{
+			// set the end delegate for the montage
+			AnimInstance->Montage_SetEndDelegate(OnAttackMontageEnded, ComboAttackMontage);
+		}
+	}
+
+}
+
+void ACombatCharacter::ChargedAttack()
+{
+	// raise the attacking flag
+	bIsAttacking = true;
+
+	// reset the charge loop flag
+	bHasLoopedChargedAttack = false;
+
+	// notify enemies they are about to be attacked
+	NotifyEnemiesOfIncomingAttack();
+
+	// play the charged attack montage
+	if (UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance())
+	{
+		const float MontageLength = AnimInstance->Montage_Play(ChargedAttackMontage, 1.0f, EMontagePlayReturnType::MontageLength, 0.0f, true);
+
+		// subscribe to montage completed and interrupted events
+		if (MontageLength > 0.0f)
+		{
+			// set the end delegate for the montage
+			AnimInstance->Montage_SetEndDelegate(OnAttackMontageEnded, ChargedAttackMontage);
+		}
+	}
+}
+
+void ACombatCharacter::AttackMontageEnded(UAnimMontage* Montage, bool bInterrupted)
+{
+	// reset the attacking flag
+	bIsAttacking = false;
+
+	// check if we have a non-stale cached input
+	if (GetWorld()->GetTimeSeconds() - CachedAttackInputTime <= AttackInputCacheTimeTolerance)
+	{
+		// are we holding the charged attack button?
+		if (bIsChargingAttack)
+		{
+			// do a charged attack
+			ChargedAttack();
+		}
+		else
+		{
+			// do a regular attack
+			ComboAttack();
+		}
+	}
+}
+
+void ACombatCharacter::DoAttackTrace(FName DamageSourceBone)
+{
+	// sweep for objects in front of the character to be hit by the attack
+	TArray<FHitResult> OutHits;
+
+	// start at the provided socket location, sweep forward
+	const FVector TraceStart = GetMesh()->GetSocketLocation(DamageSourceBone);
+	const FVector TraceEnd = TraceStart + (GetActorForwardVector() * MeleeTraceDistance);
+
+	// check for pawn and world dynamic collision object types
+	FCollisionObjectQueryParams ObjectParams;
+	ObjectParams.AddObjectTypesToQuery(ECC_Pawn);
+	ObjectParams.AddObjectTypesToQuery(ECC_WorldDynamic);
+
+	// use a sphere shape for the sweep
+	FCollisionShape CollisionShape;
+	CollisionShape.SetSphere(MeleeTraceRadius);
+
+	// ignore self
+	FCollisionQueryParams QueryParams;
+	QueryParams.AddIgnoredActor(this);
+
+	if (GetWorld()->SweepMultiByObjectType(OutHits, TraceStart, TraceEnd, FQuat::Identity, ObjectParams, CollisionShape, QueryParams))
+	{
+		// iterate over each object hit
+		for (const FHitResult& CurrentHit : OutHits)
+		{
+			// check if we've hit a damageable actor
+			ICombatDamageable* Damageable = Cast<ICombatDamageable>(CurrentHit.GetActor());
+
+			if (Damageable)
+			{
+				// knock upwards and away from the impact normal
+				const FVector Impulse = (CurrentHit.ImpactNormal * -MeleeKnockbackImpulse) + (FVector::UpVector * MeleeLaunchImpulse);
+
+				// pass the damage event to the actor
+				Damageable->ApplyDamage(MeleeDamage, this, CurrentHit.ImpactPoint, Impulse);
+
+				// call the BP handler to play effects, etc.
+				DealtDamage(MeleeDamage, CurrentHit.ImpactPoint);
+			}
+		}
+	}
+}
+
+void ACombatCharacter::CheckCombo()
+{
+	// are we playing a non-charge attack animation?
+	if (bIsAttacking && !bIsChargingAttack)
+	{
+		// is the last attack input not stale?
+		if (GetWorld()->GetTimeSeconds() - CachedAttackInputTime <= ComboInputCacheTimeTolerance)
+		{
+			// consume the attack input so we don't accidentally trigger it twice
+			CachedAttackInputTime = 0.0f;
+
+			// increase the combo counter
+			++ComboCount;
+
+			// do we still have a combo section to play?
+			if (ComboCount < ComboSectionNames.Num())
+			{
+				// notify enemies they are about to be attacked
+				NotifyEnemiesOfIncomingAttack();
+
+				// jump to the next combo section
+				if (UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance())
+				{
+					AnimInstance->Montage_JumpToSection(ComboSectionNames[ComboCount], ComboAttackMontage);
+				}
+			}
+		}
+	}
+}
+
+void ACombatCharacter::CheckChargedAttack()
+{
+	// raise the looped charged attack flag
+	bHasLoopedChargedAttack = true;
+
+	// jump to either the loop or the attack section depending on whether we're still holding the charge button
+	if (UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance())
+	{
+		AnimInstance->Montage_JumpToSection(bIsChargingAttack ? ChargeLoopSection : ChargeAttackSection, ChargedAttackMontage);
+	}
+}
+
+void ACombatCharacter::NotifyEnemiesOfIncomingAttack()
+{
+	// sweep for objects in front of the character to be hit by the attack
+	TArray<FHitResult> OutHits;
+
+	// start at the actor location, sweep forward
+	const FVector TraceStart = GetActorLocation();
+	const FVector TraceEnd = TraceStart + (GetActorForwardVector() * DangerTraceDistance);
+
+	// check for pawn object types only
+	FCollisionObjectQueryParams ObjectParams;
+	ObjectParams.AddObjectTypesToQuery(ECC_Pawn);
+
+	// use a sphere shape for the sweep
+	FCollisionShape CollisionShape;
+	CollisionShape.SetSphere(DangerTraceRadius);
+
+	// ignore self
+	FCollisionQueryParams QueryParams;
+	QueryParams.AddIgnoredActor(this);
+
+	if (GetWorld()->SweepMultiByObjectType(OutHits, TraceStart, TraceEnd, FQuat::Identity, ObjectParams, CollisionShape, QueryParams))
+	{
+		// iterate over each object hit
+		for (const FHitResult& CurrentHit : OutHits)
+		{
+			// check if we've hit a damageable actor
+			ICombatDamageable* Damageable = Cast<ICombatDamageable>(CurrentHit.GetActor());
+
+			if (Damageable)
+			{
+				// notify the enemy
+				Damageable->NotifyDanger(GetActorLocation(), this);
+			}
+		}
+	}
+}
+
+void ACombatCharacter::ApplyDamage(float Damage, AActor* DamageCauser, const FVector& DamageLocation, const FVector& DamageImpulse)
+{
+	// pass the damage event to the actor
+	FDamageEvent DamageEvent;
+	const float ActualDamage = TakeDamage(Damage, DamageEvent, nullptr, DamageCauser);
+
+	// only process knockback and effects if we received nonzero damage
+	if (ActualDamage > 0.0f)
+	{
+		// apply the knockback impulse
+		GetCharacterMovement()->AddImpulse(DamageImpulse, true);
+
+		// is the character ragdolling?
+		if (GetMesh()->IsSimulatingPhysics())
+		{
+			// apply an impulse to the ragdoll
+			GetMesh()->AddImpulseAtLocation(DamageImpulse * GetMesh()->GetMass(), DamageLocation);
+		}
+
+		// pass control to BP to play effects, etc.
+		ReceivedDamage(ActualDamage, DamageLocation, DamageImpulse.GetSafeNormal());
+	}
+
+}
+
+void ACombatCharacter::HandleDeath()
+{
+	// disable movement while we're dead
+	GetCharacterMovement()->DisableMovement();
+
+	// enable full ragdoll physics
+	GetMesh()->SetSimulatePhysics(true);
+
+	// hide the life bar
+	LifeBar->SetHiddenInGame(true);
+
+	// pull back the camera
+	GetCameraBoom()->TargetArmLength = DeathCameraDistance;
+
+	// schedule respawning
+	GetWorld()->GetTimerManager().SetTimer(RespawnTimer, this, &ACombatCharacter::RespawnCharacter, RespawnTime, false);
+}
+
+void ACombatCharacter::ApplyHealing(float Healing, AActor* Healer)
+{
+	// stub
+}
+
+void ACombatCharacter::NotifyDanger(const FVector& DangerLocation, AActor* DangerSource)
+{
+	// stub
+}
+
+void ACombatCharacter::RespawnCharacter()
+{
+	// destroy the character and let it be respawned by the Player Controller
+	Destroy();
+}
+
+float ACombatCharacter::TakeDamage(float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser)
+{
+	// only process damage if the character is still alive
+	if (CurrentHP <= 0.0f)
+	{
+		return 0.0f;
+	}
+
+	// reduce the current HP
+	CurrentHP -= Damage;
+
+	// have we run out of HP?
+	if (CurrentHP <= 0.0f)
+	{
+		// die
+		HandleDeath();
+	}
+	else
+	{
+		// update the life bar
+		LifeBarWidget->SetLifePercentage(CurrentHP / MaxHP);
+
+		// enable partial ragdoll physics, but keep the pelvis vertical
+		GetMesh()->SetPhysicsBlendWeight(0.5f);
+		GetMesh()->SetBodySimulatePhysics(PelvisBoneName, false);
+	}
+
+	// return the received damage amount
+	return Damage;
+}
+
+void ACombatCharacter::Landed(const FHitResult& Hit)
+{
+	Super::Landed(Hit);
+
+	// is the character still alive?
+	if (CurrentHP >= 0.0f)
+	{
+		// disable ragdoll physics
+		GetMesh()->SetPhysicsBlendWeight(0.0f);
+	}
+}
+
+void ACombatCharacter::BeginPlay()
+{
+	Super::BeginPlay();
+
+	// get the life bar from the widget component
+	LifeBarWidget = Cast<UCombatLifeBar>(LifeBar->GetUserWidgetObject());
+	check(LifeBarWidget);
+
+	// initialize the camera
+	GetCameraBoom()->TargetArmLength = DefaultCameraDistance;
+
+	// save the relative transform for the mesh so we can reset the ragdoll later
+	MeshStartingTransform = GetMesh()->GetRelativeTransform();
+
+	// set the life bar color
+	LifeBarWidget->SetBarColor(LifeBarColor);
+
+	// reset HP to maximum
+	ResetHP();
+}
+
+void ACombatCharacter::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+	Super::EndPlay(EndPlayReason);
+
+	// clear the respawn timer
+	GetWorld()->GetTimerManager().ClearTimer(RespawnTimer);
+}
+
+void ACombatCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
+{
+	Super::SetupPlayerInputComponent(PlayerInputComponent);
+
+	// Set up action bindings
+	if (UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent))
+	{
+		// Moving
+		EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &ACombatCharacter::Move);
+
+		// Looking
+		EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &ACombatCharacter::Look);
+		EnhancedInputComponent->BindAction(MouseLookAction, ETriggerEvent::Triggered, this, &ACombatCharacter::Look);
+
+		// Combo Attack
+		EnhancedInputComponent->BindAction(ComboAttackAction, ETriggerEvent::Started, this, &ACombatCharacter::ComboAttackPressed);
+
+		// Charged Attack
+		EnhancedInputComponent->BindAction(ChargedAttackAction, ETriggerEvent::Started, this, &ACombatCharacter::ChargedAttackPressed);
+		EnhancedInputComponent->BindAction(ChargedAttackAction, ETriggerEvent::Completed, this, &ACombatCharacter::ChargedAttackReleased);
+
+		// Camera Side Toggle
+		EnhancedInputComponent->BindAction(ToggleCameraAction, ETriggerEvent::Triggered, this, &ACombatCharacter::ToggleCamera);
+	}
+}
+
+void ACombatCharacter::NotifyControllerChanged()
+{
+	Super::NotifyControllerChanged();
+
+	// update the respawn transform on the Player Controller
+	if (ACombatPlayerController* PC = Cast<ACombatPlayerController>(GetController()))
+	{
+		PC->SetRespawnTransform(GetActorTransform());
+	}
+}
+

Source/Pockmon/Variant_Combat/CombatCharacter.h

@@ -0,0 +1,334 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Character.h"
+#include "CombatAttacker.h"
+#include "CombatDamageable.h"
+#include "Animation/AnimInstance.h"
+#include "CombatCharacter.generated.h"
+
+class USpringArmComponent;
+class UCameraComponent;
+class UInputAction;
+struct FInputActionValue;
+class UCombatLifeBar;
+class UWidgetComponent;
+
+DECLARE_LOG_CATEGORY_EXTERN(LogCombatCharacter, Log, All);
+
+/**
+ *  An enhanced Third Person Character with melee combat capabilities:
+ *  - Combo attack string
+ *  - Press and hold charged attack
+ *  - Damage dealing and reaction
+ *  - Death
+ *  - Respawning
+ */
+UCLASS(abstract)
+class ACombatCharacter : public ACharacter, public ICombatAttacker, public ICombatDamageable
+{
+	GENERATED_BODY()
+
+	/** Camera boom positioning the camera behind the character */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components", meta = (AllowPrivateAccess = "true"))
+	USpringArmComponent* CameraBoom;
+
+	/** Follow camera */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components", meta = (AllowPrivateAccess = "true"))
+	UCameraComponent* FollowCamera;
+
+	/** Life bar widget component */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components", meta = (AllowPrivateAccess = "true"))
+	UWidgetComponent* LifeBar;
+	
+protected:
+
+	/** Jump Input Action */
+	UPROPERTY(EditAnywhere, Category ="Input")
+	UInputAction* JumpAction;
+
+	/** Move Input Action */
+	UPROPERTY(EditAnywhere, Category ="Input")
+	UInputAction* MoveAction;
+
+	/** Look Input Action */
+	UPROPERTY(EditAnywhere, Category ="Input")
+	UInputAction* LookAction;
+
+	/** Mouse Look Input Action */
+	UPROPERTY(EditAnywhere, Category="Input")
+	UInputAction* MouseLookAction;
+
+	/** Combo Attack Input Action */
+	UPROPERTY(EditAnywhere, Category ="Input")
+	UInputAction* ComboAttackAction;
+
+	/** Charged Attack Input Action */
+	UPROPERTY(EditAnywhere, Category ="Input")
+	UInputAction* ChargedAttackAction;
+
+	/** Toggle Camera Side Input Action */
+	UPROPERTY(EditAnywhere, Category ="Input")
+	UInputAction* ToggleCameraAction;
+
+	/** Max amount of HP the character will have on respawn */
+	UPROPERTY(EditAnywhere, Category="Damage", meta = (ClampMin = 0, ClampMax = 100))
+	float MaxHP = 5.0f;
+
+	/** Current amount of HP the character has */
+	UPROPERTY(VisibleAnywhere, Category="Damage")
+	float CurrentHP = 0.0f;
+
+	/** Life bar widget fill color */
+	UPROPERTY(EditAnywhere, Category="Damage")
+	FLinearColor LifeBarColor;
+
+	/** Name of the pelvis bone, for damage ragdoll physics */
+	UPROPERTY(EditAnywhere, Category="Damage")
+	FName PelvisBoneName;
+
+	/** Pointer to the life bar widget */
+	UPROPERTY(EditAnywhere, Category="Damage")
+	TObjectPtr<UCombatLifeBar> LifeBarWidget;
+
+	/** Max amount of time that may elapse for a non-combo attack input to not be considered stale */
+	UPROPERTY(EditAnywhere, Category="Melee Attack", meta = (ClampMin = 0, ClampMax = 5, Units = "s"))
+	float AttackInputCacheTimeTolerance = 1.0f;
+
+	/** Time at which an attack button was last pressed */
+	float CachedAttackInputTime = 0.0f;
+
+	/** If true, the character is currently playing an attack animation */
+	bool bIsAttacking = false;
+
+	/** Distance ahead of the character that melee attack sphere collision traces will extend */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Trace", meta = (ClampMin = 0, ClampMax = 500, Units="cm"))
+	float MeleeTraceDistance = 75.0f;
+
+	/** Radius of the sphere trace for melee attacks */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Trace", meta = (ClampMin = 0, ClampMax = 200, Units = "cm"))
+	float MeleeTraceRadius = 75.0f;
+
+	/** Distance ahead of the character that enemies will be notified of incoming attacks */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Trace", meta = (ClampMin = 0, ClampMax = 500, Units="cm"))
+	float DangerTraceDistance = 300.0f;
+
+	/** Radius of the sphere trace to notify enemies of incoming attacks */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Trace", meta = (ClampMin = 0, ClampMax = 200, Units = "cm"))
+	float DangerTraceRadius = 100.0f;
+
+	/** Amount of damage a melee attack will deal */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Damage", meta = (ClampMin = 0, ClampMax = 100))
+	float MeleeDamage = 1.0f;
+
+	/** Amount of knockback impulse a melee attack will apply */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Damage", meta = (ClampMin = 0, ClampMax = 1000, Units = "cm/s"))
+	float MeleeKnockbackImpulse = 250.0f;
+
+	/** Amount of upwards impulse a melee attack will apply */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Damage", meta = (ClampMin = 0, ClampMax = 1000, Units = "cm/s"))
+	float MeleeLaunchImpulse = 300.0f;
+
+	/** AnimMontage that will play for combo attacks */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Combo")
+	UAnimMontage* ComboAttackMontage;
+
+	/** Names of the AnimMontage sections that correspond to each stage of the combo attack */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Combo")
+	TArray<FName> ComboSectionNames;
+
+	/** Max amount of time that may elapse for a combo attack input to not be considered stale */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Combo", meta = (ClampMin = 0, ClampMax = 5, Units = "s"))
+	float ComboInputCacheTimeTolerance = 0.45f;
+
+	/** Index of the current stage of the melee attack combo */
+	int32 ComboCount = 0;
+
+	/** AnimMontage that will play for charged attacks */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Charged")
+	UAnimMontage* ChargedAttackMontage;
+
+	/** Name of the AnimMontage section that corresponds to the charge loop */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Charged")
+	FName ChargeLoopSection;
+
+	/** Name of the AnimMontage section that corresponds to the attack */
+	UPROPERTY(EditAnywhere, Category="Melee Attack|Charged")
+	FName ChargeAttackSection;
+
+	/** Flag that determines if the player is currently holding the charged attack input */
+	bool bIsChargingAttack = false;
+	
+	/** If true, the charged attack hold check has been tested at least once */
+	bool bHasLoopedChargedAttack = false;
+
+	/** Camera boom length while the character is dead */
+	UPROPERTY(EditAnywhere, Category="Camera", meta = (ClampMin = 0, ClampMax = 1000, Units = "cm"))
+	float DeathCameraDistance = 400.0f;
+
+	/** Camera boom length when the character respawns */
+	UPROPERTY(EditAnywhere, Category="Camera", meta = (ClampMin = 0, ClampMax = 1000, Units = "cm"))
+	float DefaultCameraDistance = 100.0f;
+
+	/** Time to wait before respawning the character */
+	UPROPERTY(EditAnywhere, Category="Respawn", meta = (ClampMin = 0, ClampMax = 10, Units = "s"))
+	float RespawnTime = 3.0f;
+
+	/** Attack montage ended delegate */
+	FOnMontageEnded OnAttackMontageEnded;
+
+	/** Character respawn timer */
+	FTimerHandle RespawnTimer;
+
+	/** Copy of the mesh's transform so we can reset it after ragdoll animations */
+	FTransform MeshStartingTransform;
+
+public:
+	
+	/** Constructor */
+	ACombatCharacter();
+
+protected:
+
+	/** Called for movement input */
+	void Move(const FInputActionValue& Value);
+
+	/** Called for looking input */
+	void Look(const FInputActionValue& Value);
+
+	/** Called for combo attack input */
+	void ComboAttackPressed();
+
+	/** Called for combo attack input pressed */
+	void ChargedAttackPressed();
+
+	/** Called for combo attack input released */
+	void ChargedAttackReleased();
+
+	/** Called for toggle camera side input */
+	void ToggleCamera();
+
+	/** BP hook to animate the camera side switch */
+	UFUNCTION(BlueprintImplementableEvent, Category="Combat")
+	void BP_ToggleCamera();
+
+public:
+
+	/** Handles move inputs from either controls or UI interfaces */
+	UFUNCTION(BlueprintCallable, Category="Input")
+	virtual void DoMove(float Right, float Forward);
+
+	/** Handles look inputs from either controls or UI interfaces */
+	UFUNCTION(BlueprintCallable, Category="Input")
+	virtual void DoLook(float Yaw, float Pitch);
+
+	/** Handles combo attack pressed from either controls or UI interfaces */
+	UFUNCTION(BlueprintCallable, Category="Input")
+	virtual void DoComboAttackStart();
+
+	/** Handles combo attack released from either controls or UI interfaces */
+	UFUNCTION(BlueprintCallable, Category="Input")
+	virtual void DoComboAttackEnd();
+
+	/** Handles charged attack pressed from either controls or UI interfaces */
+	UFUNCTION(BlueprintCallable, Category="Input")
+	virtual void DoChargedAttackStart();
+
+	/** Handles charged attack released from either controls or UI interfaces */
+	UFUNCTION(BlueprintCallable, Category="Input")
+	virtual void DoChargedAttackEnd();
+
+protected:
+
+	/** Resets the character's current HP to maximum */
+	void ResetHP();
+
+	/** Performs a combo attack */
+	void ComboAttack();
+
+	/** Performs a charged attack */
+	void ChargedAttack();
+
+	/** Called from a delegate when the attack montage ends */
+	void AttackMontageEnded(UAnimMontage* Montage, bool bInterrupted);
+
+	
+public:
+
+	// ~begin CombatAttacker interface
+
+	/** Performs the collision check for an attack */
+	virtual void DoAttackTrace(FName DamageSourceBone) override;
+
+	/** Performs the combo string check */
+	virtual void CheckCombo() override;
+
+	/** Performs the charged attack hold check */
+	virtual void CheckChargedAttack() override;
+
+	// ~end CombatAttacker interface
+
+	// ~begin CombatDamageable interface
+
+	/** Notifies nearby enemies that an attack is coming so they can react */
+	void NotifyEnemiesOfIncomingAttack();
+
+	/** Handles damage and knockback events */
+	virtual void ApplyDamage(float Damage, AActor* DamageCauser, const FVector& DamageLocation, const FVector& DamageImpulse) override;
+
+	/** Handles death events */
+	virtual void HandleDeath() override;
+
+	/** Handles healing events */
+	virtual void ApplyHealing(float Healing, AActor* Healer) override;
+
+	/** Allows reaction to incoming attacks */
+	virtual void NotifyDanger(const FVector& DangerLocation, AActor* DangerSource) override;
+
+	// ~end CombatDamageable interface
+
+	/** Called from the respawn timer to destroy and re-create the character */
+	void RespawnCharacter();
+
+public:
+
+	/** Overrides the default TakeDamage functionality */
+	virtual float TakeDamage(float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser) override;
+
+	/** Overrides landing to reset damage ragdoll physics */
+	virtual void Landed(const FHitResult& Hit) override;
+
+protected:
+
+	/** Blueprint handler to play damage dealt effects */
+	UFUNCTION(BlueprintImplementableEvent, Category="Combat")
+	void DealtDamage(float Damage, const FVector& ImpactPoint);
+
+	/** Blueprint handler to play damage received effects */
+	UFUNCTION(BlueprintImplementableEvent, Category="Combat")
+	void ReceivedDamage(float Damage, const FVector& ImpactPoint, const FVector& DamageDirection);
+
+protected:
+
+	/** Initialization */
+	virtual void BeginPlay() override;
+
+	/** Cleanup */
+	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
+
+	/** Handles input bindings */
+	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
+
+	/** Handles possessed initialization */
+	virtual void NotifyControllerChanged() override;
+
+public:
+
+	/** Returns CameraBoom subobject **/
+	FORCEINLINE class USpringArmComponent* GetCameraBoom() const { return CameraBoom; }
+
+	/** Returns FollowCamera subobject **/
+	FORCEINLINE class UCameraComponent* GetFollowCamera() const { return FollowCamera; }
+};

Source/Pockmon/Variant_Combat/CombatGameMode.cpp

@@ -0,0 +1,9 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "Variant_Combat/CombatGameMode.h"
+
+ACombatGameMode::ACombatGameMode()
+{
+
+}

Source/Pockmon/Variant_Combat/CombatGameMode.h

@@ -0,0 +1,20 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/GameModeBase.h"
+#include "CombatGameMode.generated.h"
+
+/**
+ *  Simple GameMode for a third person combat game
+ */
+UCLASS(abstract)
+class ACombatGameMode : public AGameModeBase
+{
+	GENERATED_BODY()
+	
+public:
+
+	ACombatGameMode();
+};

Source/Pockmon/Variant_Combat/CombatPlayerController.cpp

@@ -0,0 +1,95 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "Variant_Combat/CombatPlayerController.h"
+#include "EnhancedInputSubsystems.h"
+#include "InputMappingContext.h"
+#include "Kismet/GameplayStatics.h"
+#include "GameFramework/PlayerStart.h"
+#include "CombatCharacter.h"
+#include "Engine/LocalPlayer.h"
+#include "Engine/World.h"
+#include "Blueprint/UserWidget.h"
+#include "Pockmon.h"
+#include "Widgets/Input/SVirtualJoystick.h"
+
+void ACombatPlayerController::BeginPlay()
+{
+	Super::BeginPlay();
+
+	// only spawn touch controls on local player controllers
+	if (ShouldUseTouchControls() && IsLocalPlayerController())
+	{
+		// spawn the mobile controls widget
+		MobileControlsWidget = CreateWidget<UUserWidget>(this, MobileControlsWidgetClass);
+
+		if (MobileControlsWidget)
+		{
+			// add the controls to the player screen
+			MobileControlsWidget->AddToPlayerScreen(0);
+
+		} else {
+
+			UE_LOG(LogPockmon, Error, TEXT("Could not spawn mobile controls widget."));
+
+		}
+
+	}
+}
+
+void ACombatPlayerController::SetupInputComponent()
+{
+	Super::SetupInputComponent();
+
+	// only add IMCs for local player controllers
+	if (IsLocalPlayerController())
+	{
+		// add the input mapping context
+		if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(GetLocalPlayer()))
+		{
+			for (UInputMappingContext* CurrentContext : DefaultMappingContexts)
+			{
+				Subsystem->AddMappingContext(CurrentContext, 0);
+			}
+
+			// only add these IMCs if we're not using mobile touch input
+			if (!ShouldUseTouchControls())
+			{
+				for (UInputMappingContext* CurrentContext : MobileExcludedMappingContexts)
+				{
+					Subsystem->AddMappingContext(CurrentContext, 0);
+				}
+			}
+		}
+	}
+}
+
+void ACombatPlayerController::OnPossess(APawn* InPawn)
+{
+	Super::OnPossess(InPawn);
+
+	// subscribe to the pawn's OnDestroyed delegate
+	InPawn->OnDestroyed.AddDynamic(this, &ACombatPlayerController::OnPawnDestroyed);
+}
+
+void ACombatPlayerController::SetRespawnTransform(const FTransform& NewRespawn)
+{
+	// save the new respawn transform
+	RespawnTransform = NewRespawn;
+}
+
+void ACombatPlayerController::OnPawnDestroyed(AActor* DestroyedActor)
+{
+	// spawn a new character at the respawn transform
+	if (ACombatCharacter* RespawnedCharacter = GetWorld()->SpawnActor<ACombatCharacter>(CharacterClass, RespawnTransform))
+	{
+		// possess the character
+		Possess(RespawnedCharacter);
+	}
+}
+
+bool ACombatPlayerController::ShouldUseTouchControls() const
+{
+	// are we on a mobile platform? Should we force touch?
+	return SVirtualJoystick::ShouldDisplayTouchInterface() || bForceTouchControls;
+}

Source/Pockmon/Variant_Combat/CombatPlayerController.h

@@ -0,0 +1,76 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/PlayerController.h"
+#include "CombatPlayerController.generated.h"
+
+class UInputMappingContext;
+class ACombatCharacter;
+
+/**
+ *  Simple Player Controller for a third person combat game
+ *  Manages input mappings
+ *  Respawns the player character at the checkpoint when it's destroyed
+ */
+UCLASS(abstract, Config="Game")
+class ACombatPlayerController : public APlayerController
+{
+	GENERATED_BODY()
+	
+protected:
+
+	/** Input mapping context for this player */
+	UPROPERTY(EditAnywhere, Category="Input|Input Mappings")
+	TArray<UInputMappingContext*> DefaultMappingContexts;
+
+	/** Input Mapping Contexts */
+	UPROPERTY(EditAnywhere, Category="Input|Input Mappings")
+	TArray<UInputMappingContext*> MobileExcludedMappingContexts;
+
+	/** Mobile controls widget to spawn */
+	UPROPERTY(EditAnywhere, Category="Input|Touch Controls")
+	TSubclassOf<UUserWidget> MobileControlsWidgetClass;
+
+	/** Pointer to the mobile controls widget */
+	UPROPERTY()
+	TObjectPtr<UUserWidget> MobileControlsWidget;
+
+	/** If true, the player will use UMG touch controls even if not playing on mobile platforms */
+	UPROPERTY(EditAnywhere, Config, Category = "Input|Touch Controls")
+	bool bForceTouchControls = false;
+
+	/** Character class to respawn when the possessed pawn is destroyed */
+	UPROPERTY(EditAnywhere, Category="Respawn")
+	TSubclassOf<ACombatCharacter> CharacterClass;
+
+	/** Transform to respawn the character at. Can be set to create checkpoints */
+	FTransform RespawnTransform;
+
+protected:
+
+	/** Gameplay initialization */
+	virtual void BeginPlay() override;
+
+	/** Initialize input bindings */
+	virtual void SetupInputComponent() override;
+
+	/** Pawn initialization */
+	virtual void OnPossess(APawn* InPawn) override;
+
+public:
+
+	/** Updates the character respawn transform */
+	void SetRespawnTransform(const FTransform& NewRespawn);
+
+protected:
+
+	/** Called if the possessed pawn is destroyed */
+	UFUNCTION()
+	void OnPawnDestroyed(AActor* DestroyedActor);
+
+	/** Returns true if the player should use UMG touch controls */
+	bool ShouldUseTouchControls() const;
+
+};

Source/Pockmon/Variant_Combat/Gameplay/CombatActivationVolume.cpp

@@ -0,0 +1,49 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatActivationVolume.h"
+#include "Components/BoxComponent.h"
+#include "GameFramework/Character.h"
+#include "CombatActivatable.h"
+
+ACombatActivationVolume::ACombatActivationVolume()
+{
+	PrimaryActorTick.bCanEverTick = false;
+
+	// create the box volume
+	RootComponent = Box = CreateDefaultSubobject<UBoxComponent>(TEXT("Box"));
+	check(Box);
+
+	// set the box's extent
+	Box->SetBoxExtent(FVector(500.0f, 500.0f, 500.0f));
+
+	// set the default collision profile to overlap all dynamic
+	Box->SetCollisionProfileName(FName("OverlapAllDynamic"));
+
+	// bind the begin overlap 
+	Box->OnComponentBeginOverlap.AddDynamic(this, &ACombatActivationVolume::OnOverlap);
+}
+
+void ACombatActivationVolume::OnOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
+{
+	// has a Character entered the volume?
+	ACharacter* PlayerCharacter = Cast<ACharacter>(OtherActor);
+
+	if (PlayerCharacter)
+	{
+		// is the Character controlled by a player
+		if (PlayerCharacter->IsPlayerControlled())
+		{
+			// process the actors to activate list
+			for (AActor* CurrentActor : ActorsToActivate)
+			{
+				// is the referenced actor activatable?
+				if(ICombatActivatable* Activatable = Cast<ICombatActivatable>(CurrentActor))
+				{
+					Activatable->ActivateInteraction(PlayerCharacter);
+				}
+			}
+		}
+	}
+
+}

Source/Pockmon/Variant_Combat/Gameplay/CombatActivationVolume.h

@@ -0,0 +1,40 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "CombatActivationVolume.generated.h"
+
+class UBoxComponent;
+
+/**
+ *  A simple volume that activates a list of actors when the player pawn enters.
+ */
+UCLASS()
+class ACombatActivationVolume : public AActor
+{
+	GENERATED_BODY()
+
+	/** Collision box volume */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category ="Components", meta = (AllowPrivateAccess = "true"))
+	UBoxComponent* Box;
+	
+protected:
+
+	/** List of actors to activate when this volume is entered */
+	UPROPERTY(EditAnywhere, Category="Activation Volume")
+	TArray<AActor*> ActorsToActivate;
+
+public:	
+	
+	/** Constructor */
+	ACombatActivationVolume();
+
+protected:
+
+	/** Handles overlaps with the box volume */
+	UFUNCTION()
+	void OnOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
+
+};

Source/Pockmon/Variant_Combat/Gameplay/CombatCheckpointVolume.cpp

@@ -0,0 +1,47 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatCheckpointVolume.h"
+#include "CombatCharacter.h"
+#include "CombatPlayerController.h"
+
+ACombatCheckpointVolume::ACombatCheckpointVolume()
+{
+	// create the box volume
+	RootComponent = Box = CreateDefaultSubobject<UBoxComponent>(TEXT("Box"));
+	check(Box);
+
+	// set the box's extent
+	Box->SetBoxExtent(FVector(500.0f, 500.0f, 500.0f));
+
+	// set the default collision profile to overlap all dynamic
+	Box->SetCollisionProfileName(FName("OverlapAllDynamic"));
+
+	// bind the begin overlap 
+	Box->OnComponentBeginOverlap.AddDynamic(this, &ACombatCheckpointVolume::OnOverlap);
+}
+
+void ACombatCheckpointVolume::OnOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
+{
+	// ensure we use this only once
+	if (bCheckpointUsed)
+	{
+		return;
+	}
+		
+	// has the player entered this volume?
+	ACombatCharacter* PlayerCharacter = Cast<ACombatCharacter>(OtherActor);
+
+	if (PlayerCharacter)
+	{
+		if (ACombatPlayerController* PC = Cast<ACombatPlayerController>(PlayerCharacter->GetController()))
+		{
+			// raise the checkpoint used flag
+			bCheckpointUsed = true;
+
+			// update the player's respawn checkpoint
+			PC->SetRespawnTransform(PlayerCharacter->GetActorTransform());
+		}
+
+	}
+}

Source/Pockmon/Variant_Combat/Gameplay/CombatCheckpointVolume.h

@@ -0,0 +1,32 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "Components/BoxComponent.h"
+#include "CombatCheckpointVolume.generated.h"
+
+UCLASS(abstract)
+class ACombatCheckpointVolume : public AActor
+{
+	GENERATED_BODY()
+	
+	/** Collision box volume */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Components, meta = (AllowPrivateAccess = "true"))
+	UBoxComponent* Box;
+
+public:	
+	
+	/** Constructor */
+	ACombatCheckpointVolume();
+
+protected:
+
+	/** Set to true after use to avoid accidentally resetting the checkpoint */
+	bool bCheckpointUsed = false;
+
+	/** Handles overlaps with the box volume */
+	UFUNCTION()
+	void OnOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
+};

Source/Pockmon/Variant_Combat/Gameplay/CombatDamageableBox.cpp

@@ -0,0 +1,83 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatDamageableBox.h"
+#include "Components/StaticMeshComponent.h"
+#include "TimerManager.h"
+#include "Engine/World.h"
+
+ACombatDamageableBox::ACombatDamageableBox()
+{
+	PrimaryActorTick.bCanEverTick = false;
+
+	// create the mesh
+	RootComponent = Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
+
+	// set the collision properties
+	Mesh->SetCollisionProfileName(FName("BlockAllDynamic"));
+
+	// enable physics
+	Mesh->SetSimulatePhysics(true);
+
+	// disable navigation relevance so boxes don't affect NavMesh generation
+	Mesh->bNavigationRelevant = false;
+}
+
+void ACombatDamageableBox::RemoveFromLevel()
+{
+	// destroy this actor
+	Destroy();
+}
+
+void ACombatDamageableBox::EndPlay(EEndPlayReason::Type EndPlayReason)
+{
+	Super::EndPlay(EndPlayReason);
+
+	// clear the death timer
+	GetWorld()->GetTimerManager().ClearTimer(DeathTimer);
+}
+
+void ACombatDamageableBox::ApplyDamage(float Damage, AActor* DamageCauser, const FVector& DamageLocation, const FVector& DamageImpulse)
+{
+	// only process damage if we still have HP
+	if (CurrentHP > 0.0f)
+	{
+		// apply the damage
+		CurrentHP -= Damage;
+
+		// are we dead?
+		if (CurrentHP <= 0.0f)
+		{
+			HandleDeath();
+		}
+
+		// apply a physics impulse to the box, ignoring its mass
+		Mesh->AddImpulseAtLocation(DamageImpulse * Mesh->GetMass(), DamageLocation);
+
+		// call the BP handler to play effects, etc.
+		OnBoxDamaged(DamageLocation, DamageImpulse);
+	}
+}
+
+void ACombatDamageableBox::HandleDeath()
+{
+	// change the collision object type to Visibility so we ignore most interactions but still retain physics collisions
+	Mesh->SetCollisionObjectType(ECC_Visibility);
+
+	// call the BP handler to play effects, etc.
+	OnBoxDestroyed();
+
+	// set up the death cleanup timer
+	GetWorld()->GetTimerManager().SetTimer(DeathTimer, this, &ACombatDamageableBox::RemoveFromLevel, DeathDelayTime);
+}
+
+void ACombatDamageableBox::ApplyHealing(float Healing, AActor* Healer)
+{
+	// stub
+}
+
+void ACombatDamageableBox::NotifyDanger(const FVector& DangerLocation, AActor* DangerSource)
+{
+	// stub
+}
+

Source/Pockmon/Variant_Combat/Gameplay/CombatDamageableBox.h

@@ -0,0 +1,71 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "CombatDamageable.h"
+#include "CombatDamageableBox.generated.h"
+
+/**
+ *  A simple physics box that reacts to damage through the ICombatDamageable interface
+ */
+UCLASS(abstract)
+class ACombatDamageableBox : public AActor, public ICombatDamageable
+{
+	GENERATED_BODY()
+	
+	/** Damageable box mesh */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components", meta = (AllowPrivateAccess = "true"))
+	UStaticMeshComponent* Mesh;
+
+public:	
+
+	/** Constructor */
+	ACombatDamageableBox();
+
+protected:
+
+	/** Amount of HP this box starts with. */
+	UPROPERTY(EditAnywhere, Category="Damage")
+	float CurrentHP = 3.0f;
+
+	/** Time to wait before we remove this box from the level. */
+	UPROPERTY(EditAnywhere, Category="Damage", meta = (ClampMin = 0, ClampMax = 10, Units = "s"))
+	float DeathDelayTime = 6.0f;
+
+	/** Timer to defer destruction of this box after its HP are depleted */
+	FTimerHandle DeathTimer;
+
+	/** Blueprint damage handler for effect playback */
+	UFUNCTION(BlueprintImplementableEvent, Category="Damage")
+	void OnBoxDamaged(const FVector& DamageLocation, const FVector& DamageImpulse);
+
+	/** Blueprint destruction handler for effect playback */
+	UFUNCTION(BlueprintImplementableEvent, Category="Damage")
+	void OnBoxDestroyed();
+
+	/** Timer callback to remove the box from the level after it dies */
+	void RemoveFromLevel();
+
+public:
+
+	/** EndPlay cleanup */
+	void EndPlay(EEndPlayReason::Type EndPlayReason) override;
+
+	// ~Begin CombatDamageable interface
+
+	/** Handles damage and knockback events */
+	virtual void ApplyDamage(float Damage, AActor* DamageCauser, const FVector& DamageLocation, const FVector& DamageImpulse) override;
+
+	/** Handles death events */
+	virtual void HandleDeath() override;
+
+	/** Handles healing events */
+	virtual void ApplyHealing(float Healing, AActor* Healer) override;
+
+	/** Allows reaction to incoming attacks */
+	virtual void NotifyDanger(const FVector& DangerLocation, AActor* DangerSource) override;
+
+	// ~End CombatDamageable interface
+};

Source/Pockmon/Variant_Combat/Gameplay/CombatDummy.cpp

@@ -0,0 +1,56 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatDummy.h"
+#include "Components/SceneComponent.h"
+#include "Components/StaticMeshComponent.h"
+#include "PhysicsEngine/PhysicsConstraintComponent.h"
+
+ACombatDummy::ACombatDummy()
+{
+ 	PrimaryActorTick.bCanEverTick = true;
+
+	// create the root
+	Root = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
+	SetRootComponent(Root);
+
+	// create the base plate
+	BasePlate = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Base Plate"));
+	BasePlate->SetupAttachment(RootComponent);
+
+	// create the dummy
+	Dummy = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Dummy"));
+	Dummy->SetupAttachment(RootComponent);
+
+	Dummy->SetSimulatePhysics(true);
+
+	// create the physics constraint
+	PhysicsConstraint = CreateDefaultSubobject<UPhysicsConstraintComponent>(TEXT("Physics Constraint"));
+	PhysicsConstraint->SetupAttachment(RootComponent);
+
+	PhysicsConstraint->SetConstrainedComponents(BasePlate, NAME_None, Dummy, NAME_None);
+}
+
+void ACombatDummy::ApplyDamage(float Damage, AActor* DamageCauser, const FVector& DamageLocation, const FVector& DamageImpulse)
+{
+	// apply impulse to the dummy
+	Dummy->AddImpulseAtLocation(DamageImpulse, DamageLocation);
+
+	// call the BP handler
+	BP_OnDummyDamaged(DamageLocation, DamageImpulse.GetSafeNormal());
+}
+
+void ACombatDummy::HandleDeath()
+{
+	// unused
+}
+
+void ACombatDummy::ApplyHealing(float Healing, AActor* Healer)
+{
+	// unused
+}
+
+void ACombatDummy::NotifyDanger(const FVector& DangerLocation, AActor* DangerSource)
+{
+	// unused
+}

Source/Pockmon/Variant_Combat/Gameplay/CombatDummy.h

@@ -0,0 +1,63 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "CombatDamageable.h"
+#include "CombatDummy.generated.h"
+
+class UStaticMeshComponent;
+class UPhysicsConstraintComponent;
+
+/**
+ *  A simple invincible combat training dummy
+ */
+UCLASS(abstract)
+class ACombatDummy : public AActor, public ICombatDamageable
+{
+	GENERATED_BODY()
+	
+	/** Root component */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components", meta = (AllowPrivateAccess = "true"))
+	USceneComponent* Root;
+
+	/** Static base plate */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components", meta = (AllowPrivateAccess = "true"))
+	UStaticMeshComponent* BasePlate;
+
+	/** Physics enabled dummy mesh */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components", meta = (AllowPrivateAccess = "true"))
+	UStaticMeshComponent* Dummy;
+
+	/** Physics constraint holding the dummy and base plate together */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components", meta = (AllowPrivateAccess = "true"))
+	UPhysicsConstraintComponent* PhysicsConstraint;
+
+public:	
+	
+	/** Constructor */
+	ACombatDummy();
+
+	// ~Begin CombatDamageable interface
+
+		/** Handles damage and knockback events */
+	virtual void ApplyDamage(float Damage, AActor* DamageCauser, const FVector& DamageLocation, const FVector& DamageImpulse) override;
+
+	/** Handles death events */
+	virtual void HandleDeath() override;
+
+	/** Handles healing events */
+	virtual void ApplyHealing(float Healing, AActor* Healer) override;
+
+	/** Allows reaction to incoming attacks */
+	virtual void NotifyDanger(const FVector& DangerLocation, AActor* DangerSource) override;
+
+	// ~End CombatDamageable interface
+
+protected:
+
+	/** Blueprint handle to apply damage effects */
+	UFUNCTION(BlueprintImplementableEvent, Category="Combat", meta = (DisplayName = "On Dummy Damaged"))
+	void BP_OnDummyDamaged(const FVector& Location, const FVector& Direction);
+};

Source/Pockmon/Variant_Combat/Gameplay/CombatLavaFloor.cpp

@@ -0,0 +1,27 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatLavaFloor.h"
+#include "CombatDamageable.h"
+#include "Components/StaticMeshComponent.h"
+
+ACombatLavaFloor::ACombatLavaFloor()
+{
+	PrimaryActorTick.bCanEverTick = false;
+
+	// create the mesh
+	RootComponent = Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
+
+	// bind the hit handler
+	Mesh->OnComponentHit.AddDynamic(this, &ACombatLavaFloor::OnFloorHit);
+}
+
+void ACombatLavaFloor::OnFloorHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit)
+{
+	// check if the hit actor is damageable by casting to the interface
+	if (ICombatDamageable* Damageable = Cast<ICombatDamageable>(OtherActor))
+	{
+		// damage the actor
+		Damageable->ApplyDamage(Damage, this, Hit.ImpactPoint, FVector::ZeroVector);
+	}
+}

Source/Pockmon/Variant_Combat/Gameplay/CombatLavaFloor.h

@@ -0,0 +1,40 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "CombatLavaFloor.generated.h"
+
+class UStaticMeshComponent;
+class UPrimitiveComponent;
+
+/**
+ *  A basic actor that applies damage on contact through the ICombatDamageable interface. 
+ */
+UCLASS(abstract)
+class ACombatLavaFloor : public AActor
+{
+	GENERATED_BODY()
+	
+	/** Floor mesh */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components", meta = (AllowPrivateAccess = "true"))
+	UStaticMeshComponent* Mesh;
+
+protected:
+
+	/** Amount of damage to deal on contact */
+	UPROPERTY(EditAnywhere, Category="Damage")
+	float Damage = 10000.0f;
+
+public:	
+
+	/** Constructor */
+	ACombatLavaFloor();
+
+protected:
+
+	/** Blocking hit handler */
+	UFUNCTION()
+	void OnFloorHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit);
+};

Source/Pockmon/Variant_Combat/Interfaces/CombatActivatable.cpp

@@ -0,0 +1,4 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatActivatable.h"

Source/Pockmon/Variant_Combat/Interfaces/CombatActivatable.h

@@ -0,0 +1,36 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Interface.h"
+#include "CombatActivatable.generated.h"
+
+/**
+ *  Interactable Interface
+ *  Provides a context-agnostic way of activating, deactivating or toggling actors
+ */
+UINTERFACE(MinimalAPI, NotBlueprintable)
+class UCombatActivatable : public UInterface
+{
+	GENERATED_BODY()
+};
+
+class ICombatActivatable
+{
+	GENERATED_BODY()
+
+public:
+
+	/** Toggles the Interactable Actor */
+	UFUNCTION(BlueprintCallable, Category="Activatable")
+	virtual void ToggleInteraction(AActor* ActivationInstigator) = 0;
+
+	/** Activates the Interactable Actor */
+	UFUNCTION(BlueprintCallable, Category="Activatable")
+	virtual void ActivateInteraction(AActor* ActivationInstigator) = 0;
+
+	/** Deactivates the Interactable Actor */
+	UFUNCTION(BlueprintCallable, Category="Activatable")
+	virtual void DeactivateInteraction(AActor* ActivationInstigator) = 0;
+};

Source/Pockmon/Variant_Combat/Interfaces/CombatAttacker.cpp

@@ -0,0 +1,4 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatAttacker.h"

Source/Pockmon/Variant_Combat/Interfaces/CombatAttacker.h

@@ -0,0 +1,36 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Interface.h"
+#include "CombatAttacker.generated.h"
+
+/**
+ *  CombatAttacker Interface
+ *  Provides common functionality to trigger attack animation events.
+ */
+UINTERFACE(MinimalAPI, NotBlueprintable)
+class UCombatAttacker : public UInterface
+{
+	GENERATED_BODY()
+};
+
+class ICombatAttacker
+{
+	GENERATED_BODY()
+
+public:
+
+	/** Performs an attack's collision check. Usually called from a montage's AnimNotify */
+	UFUNCTION(BlueprintCallable, Category="Attacker")
+	virtual void DoAttackTrace(FName DamageSourceBone) = 0;
+
+	/** Performs a combo attack's check to continue the string. Usually called from a montage's AnimNotify */
+	UFUNCTION(BlueprintCallable, Category="Attacker")
+	virtual void CheckCombo() = 0;
+
+	/** Performs a charged attack's check to loop the charge animation. Usually called from a montage's AnimNotify */
+	UFUNCTION(BlueprintCallable, Category="Attacker")
+	virtual void CheckChargedAttack() = 0;
+};

Source/Pockmon/Variant_Combat/Interfaces/CombatDamageable.cpp

@@ -0,0 +1,6 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "CombatDamageable.h"
+
+// Add default functionality here for any ICombatDamageable functions that are not pure virtual.

Source/Pockmon/Variant_Combat/Interfaces/CombatDamageable.h

@@ -0,0 +1,41 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Interface.h"
+#include "CombatDamageable.generated.h"
+
+/**
+ *  CombatDamageable interface
+ *  Provides functionality to handle damage, healing, knockback and death
+ *  Also provides functionality to warn characters of incoming sources of damage
+ */
+UINTERFACE(MinimalAPI, NotBlueprintable)
+class UCombatDamageable : public UInterface
+{
+	GENERATED_BODY()
+};
+
+class ICombatDamageable
+{
+	GENERATED_BODY()
+
+public:
+
+	/** Handles damage and knockback events */
+	UFUNCTION(BlueprintCallable, Category="Damageable")
+	virtual void ApplyDamage(float Damage, AActor* DamageCauser, const FVector& DamageLocation, const FVector& DamageImpulse) = 0;
+
+	/** Handles death events */
+	UFUNCTION(BlueprintCallable, Category="Damageable")
+	virtual void HandleDeath() = 0;
+
+	/** Handles healing events */
+	UFUNCTION(BlueprintCallable, Category="Damageable")
+	virtual void ApplyHealing(float Healing, AActor* Healer) = 0;
+
+	/** Notifies the actor of impending danger such as an incoming hit, allowing it to react. */
+	UFUNCTION(BlueprintCallable, Category="Damageable")
+	virtual void NotifyDanger(const FVector& DangerLocation, AActor* DangerSource) = 0;
+};