With this class set up, I create a blueprint class which inherited from this one - this way I can set the mesh through blueprint & easily edit properties of the hit box. For the hitbox, I added a new Object Channel for collision filtering for an Attackable object:

I also created two new presets for the attacking - once for the PlayerAttack which overlaps the Attackable objects, and one for the Attackable which blocks all incoming objects.
​For the Dagger blueprint, I created a hitbox that was slightly bigger than the dagger to make the weapon collisions a bit more player-friendly. The end result of the blueprint was this:

The next step is to have the dagger spawn in the Player's hand. I opened up my Character class and in the header I added a couple of new fields - a TSubclassOf<Dagger> and the Dagger instance itself. I used this method so that in the blueprint I am able to easily change the Dagger class if I ever need to - in the future I'll make a subclass called Weapon so that I can switch the type of weapon the player has. I also added a getter for the weapon.
In the BeginPlay of my character I spawned my Dagger and attached it to the sword socket on the player:

Next I need to edit my character's skeleton to actually add the socket for the weapon. In the skeleton, I added the socket to the MiddleHand_R bone and set the transforms so that the dagger fits correctly into the hand:

The last class I need to edit is the Player's Attack state so that I can activate the weapon. 
First, I updated the SetCharacter method in the state to cast the character to a PlayerCharacter object - this way I can retrieve the weapon when required:

Next, I updated the OnEnter method so that I can retrieve the player's weapon & the hitbox, and then register my callback for when the collision box overlaps an object:

For the next step I had to add the method for the callback. For this method I had to add a couple of new fields to my state:

• hitActors_ - This is a TArray of all the Actors that have been hit in the current attack. This will be compared against during the overlap so that an Actor isn't accidentally hit twice if they're moving.
• damage_ - This is the amount of damage that the attack will perform.

In the callback method, I first iterate through the list of actors and check that the current actor hasn't already been hit. If it hasn't I add the actor to the list and apply point damage to it:

Next I had to update the OnMessageReceived method to perform extra functionality during certain messages:

• In OnAttackStart, I allow the hitbox to generate overlap events
• In OnAttackEnd, I disable the hitbox's ability to generate overlap events again
  
• In OnAttackComplete, I empty the list of actors so that the next attack starts fresh, allowing all objects to be hit again. 

Finally, in the OnExit method if the hitbox exists I de-register my callback from the hitbox.

Now all I needed to do was test the attack! For testing purposes I created a new Blueprint class for a crate, and attach a box mesh to the object. In the event graph, I added a node for the PointDamage event and used this to damage the crate. The health is decremented, and if it is less than zero the crate is destroyed. I also set the default of the health to 5 so that it can be destroyed in one hit.

Now, when I run the game you can see the attack!

With the attack system now in place, the next area of the game I'm going to be looking at is the Stop Time ability! This system will also be split into multiple posts, so stay tuned!

In the OnAttackStart and OnAttackEnd, I will eventually activate the weapon however for now I have activated & deactivated the combo area. The OnAttackComplete message resets the playNextAttack boolean so that the player can trigger another combo attack. Finally, the OnAnimationComplete message will change the state to the Idle state.
Next I have overridden the the OnActionInputReceived method, where I check if the input is the Attack input, and if it is the player can attempt to combo an attack. The method looks like the following:

Finally, I overrode the OnExit method to stop the attack on the animation instance.

I had to create a subclass of the animation instance so I could add my own custom methods for performing the attacks. I added a variable for the animation montage of the attack, and 3 methods - StartAttack, ChangeAttack and StopAttack:

In the ChangeAttack method, I form the section names for the montage & tell the montage to set the next section. The StartAttack method simply starts the montage, and the StopAttack method stops the montage. Once this class was complete I re-parented the animation blueprint of the player to my new class.
The last step was to add the state to the PlayerController. Now, the player can attack:

In the next post I will discuss how I implemented the hitbox & the particle effect for the attack.

By default, each section will play an animation and if it is not told to play another section it will play the wind-down animation and end the attack.
For the next part of this montage I needed to add the notify events so that the state can be messaged when the attack end, when the animation is complete and when the attack should be activated.
For the AttackComplete and AnimationComplete events I used a basic Notify, whereas for the Attack active state I used a NotifyState - this way I can make the attack active with the NotifyBegin and NotifyEnd methods.
I created a subclass for the NotifyState which is used to notify the PlayerController about the attack becoming active using a message. Currently, the NotifyState only works with the PlayerController but in the future I might need to refactor this to be more generic. In the end, this class looks like this: 

I added multiple null checks into the GetPlayerController method to ensure that the PlayerController is valid, and I send the attack start & end message through to the player controller if it is. 
​I then added the notifications into the animation montage at key points during each animation, so the final result looked like this:

Now with the montage setup I needed to add the montage to the animation blueprint. First, I updated the AnimGraph to play the montage between the default pose like so:

I assigned the slot to be the AttackSlot that I defined, and hooked up the animation to the final animation pose.
I then updated the EventGraph for the new animation to allow for sending messages to the player controller after the montage events:

I added three variables to the blueprint - an FName for the Attack completing, an FName for the Animation completing and a PlayerController instance. I added the PlayerController so that I wouldn't have to continuously cast the controller for the notifies.
I then implemented the BeginPlay method to obtain the player controller & set it.
Finally I added the events for both AnimNotify events which will simply send a message to the player controller.

The animation blueprint & the animation are now both ready for the attacks! The next post will discuss the implementation of the Attack state.

So when a state begins, the OnEnter is called and when its complete OnExit is called. When the states are created the PlayerController sets the OnComplete callback and the Character that the state will alter. When the PlayerController receives any input or messages, they are forwarded on to the state. For the OnComplete callback and the Character, I decided to keep those methods pure as interfaces should not contain any logic.
For the OnComplete callback, I used Unreal's Dynamic Delegate with 1 parameter so that the state can tell the controller which state to enter next. The delegate looks like this:

I then added a new state for the player called USPlayerIdle, which inherits from UObject and IState. For this state, I moved the movement logic in from the PlayerController which looks like this:

In the OnActionInputReceived method, I've added a check for the Attack input binding which will execute the OnComplete callback to start the Attack state. The rest of the state is empty for now. 

The last change I had to perform was to the PlayerController to take into account the player's state. I've added a new PopulateStateList method which will fill a TMap with implementations of the IState interface, with the key being an FName. I added an InitialiseStates method which then passes through the OnComplete delegate and the character to each state - this method looks like the following:

In BeginPlay, I call the two new methods & set the current state to be my new Idle/Movement state. Finally, I altered the input methods to pass the input to the current state as so:

So now its back to where it was before, but cleaner!

Next post will be the Attack implementation, which might be split into 2 depending on the length.

Once the process is complete, the model should be available in Unreal.

The next thing I needed to do was to rework the animation blueprint for the new character. I decided to create a new blueprint rather than rework the existing one as it would be simpler to work it that way. However, I did base it on the previous one. For the run animation, I used a BlendSpace between the Idle, Walk & Run animations so that as the player's speed increases, it will change the animation as seen below.

Next I made the blueprint for the animation - this is essentially a copy of the other animation blueprint but with the new character's animations. 
Finally, in the character blueprint on the mesh component I changed the skeletal mesh and selected my new animation blueprint as seen below:

Now, if I play the game we can see the new character!

The next target for the project will be an attack system.

In here you can add the bindings for any input in the game. Action Mappings are used for input without a scaling value, such as a button press on a keypad, whereas Axis Mapping will provide you with a scaling value between 0 and 1 that can be used to scale the movement speed for example. I've added a new Action Mapping first for a Jump method which is triggered by the space bar or with the bottom face button on a GamePad - on an Xbox controller this translates to the A button. 

Next I added some Axis Mappings - these are used for character movement as I want my character to move slower if the analog stick is only slightly pressed. There were already some keyboard bindings in here, so I added a couple of bindings for the thumbsticks like so:

Now onto the fun bit - the code! The standard PlayerController that comes with the test project has a lot of redundant code that I didn't really need for my game, so I created a new one. It's quite a simple class, all it does is bind the input for the mappings defined above. Luckily the Pawn and Character classes have the functionality that I need, so when MoveForward/MoveRight are called I call GetPawn()->AddMovementInput and pass in the direction and the scale value. For the Jump method, I just need to call Jump on the character being controlled - the final class looks like this:

Now there's some basic movement working! However there were still some tweaks that I needed to do as the movement didn't feel right. First, the character looked like he was sliding around - to fix this, in the custom character class I set the ground friction to 300. This seemed to do the trick, however it may need tweaking in the future.

Next, I wanted a bit of movement in the air so that if the player tries to change direction while jumping it'll move slightly - this was another easy fix, on the character I set AirControl to 1.

Finally, the camera angle wasn't what I was after, I wanted it to be rotated down a little bit more. This was a bit trickier than it should have been, as something was changing my rotation of the spring arm component back to its default. This was due to the Blueprint of the character trying to set it back to the default - after setting the change in the blueprint the issue seemed to be resolved!

The end result looks like this:

In the next post, I'll explain how I switched the default player model into a custom one.