2 June 2024: This article has been updated to correct some errors and missing information.
Thanks to Allan Valin for pointing these out to us! Check out this post to see a list of common issues readers run into with this part of the series.
Welcome to Part 4 of our Metroidvania tutorial series, where we’ll be taking you on a journey through the development process of creating your own Metroidvania game, just like the widely popular Hollow Knight, in Unity!
Table of Contents:
- Introduction
- Part 3 Enhancements
- Hearts UI system
- Player healing
- Player Mana
- Spellcasting
- Wrap up
- Conclusion
Update 13 June 2024: A video has been created to highlight some of the issues in the video. If you are reading this article for more information after watching our Part 4 video, you may also find it useful to watch the video below:
1. Introduction
In this part, we will be delving into the creation of a hearts UI system, a spellcasting system, and a mana system. These innovative mechanics will grant players a multitude of options for gameplay, elevating its allure and making it even more enthralling to partake in.
But before we dive into today’s content, we will make some noteworthy enhancements to what we had crafted in the previous part.
2. Part 3 Enhancements
a. General Improvements
i. Health system revamp
Firstly, we will introduce a much simpler health system. Within the PlayerController, we will eliminate the ClampHealth() function along with all its references.
Instead, we will establish an integer property called Health and retrieve its value. If the current health differs from the value stored in the Health property, we will update the health accordingly. Moving forward, we will replace all instances where we refer to the health with the Health property.
By using the Health property instead of ClampHealth(), we don’t have to keep calling ClampHealth() every time we need to update the health. This way, when we change the health, everything related to it updates on its own, without us needing to do extra steps. This makes the code easier to understand and manage, as all health updates are done automatically when we use the Health property. Plus, it’s less intensive on the system and more optimized, because we’re not constantly running the ClampHealth() method. That means our game runs smoother and more efficiently when we use the Health property.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if(Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
health Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
Flip();
Move();
Jump();
StartDash();
Attack();
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetMouseButtonDown(0);
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if(Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if(attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if(yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if(yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if(pState.recoilingX)
{
if(pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if(pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if(pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if(Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
health Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
anim.SetTrigger("TakeDamage");
ClampHealth();
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void ClampHealth()
{
health = Mathf.Clamp(health, 0, maxHealth);
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
}
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
ii. Attacking using the Input Manager
Previously, we called the attack function by getting the mouse input directly, now, let’s change it to the Input Manager so if the player wants to use another button to attack, they can change it accordingly. compared to getting the left mouse button directly, this is much more versatile.
In the Input Manager, let’s change “Fire1” to “Attack“. We will be using the left mouse button (Mouse 0) for it.
In the PlayerController, we will update the attack input to use the “Attack” input from the input manager.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if(Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
Flip();
Move();
Jump();
StartDash();
Attack();
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetMouseButtonDown(0);
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if(Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if(attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if(yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if(yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if(pState.recoilingX)
{
if(pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if(pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if(pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if(Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
}
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
iii. Creating a FixedUpdate() for Recoiling and Dashing
Moving forward, we will create a void FixedUpdate() function and return the dashing state and transfer the Recoil() function into it. This adjustment is necessary because FixedUpdate() is influenced by the timescale, whereas Update() runs every frame regardless. By implementing this change, we ensure that when the game is paused, we won’t dash or recoil.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if(Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
Flip();
Move();
Jump();
StartDash();
Attack();
Recoil();
}
private void FixedUpdate()
{
if (pState.dashing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if(Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if(attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if(yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if(yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if(pState.recoilingX)
{
if(pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if(pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if(pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if(Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
}
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
b. Feedback when Player is hit
i. Hit Particle effect when Player is hit
Next up, we will add a particle hit effect to depict when the player sustains damage.
Let’s create a Particle System and name it Blood Spurt.
Then, make the following changes to the particle effect.
Please note that the following particle effect settings are the ones I will be using. Feel free to make your own modifications as you see fit.
- The duration to 0.25 and uncheck the looping option.
- The lifetime to 2 and the speed to 50.
- The start size to range between two constants, specifically 3 and 8.
- The gravity modifier to -0.7.
- Tet the maximum particles to 30, and adjust the rate over time to 1000.
- The shape to a circle and reset its rotation.
- The scale the shape to 0.25 for the Y-axis.
- The velocity over the lifetime to be in world space, and ensure the size over lifetime option is checked.
Following that, we will create a Material called Blood Material and set it to Particle > Standard Unlit.
An Unlit material is a material that is not affected by scene lighting. Since our game is a 2D platformer without any lights, if we use a Lit material, it will appear very dark.
Import the particle from the knight asset pack into the albedo slot and change the rendering mode to Cutout. Assign the Blood Material to the Particle System renderer. Then turn both the Blood Material and Blood Spurt into a prefab and recenter the Blood Spurt.
Finally, in the PlayerController, we’ll create a GameObject bloodSpurt and instantiate it after the player has been hit.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if(Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
Flip();
Move();
Jump();
StartDash();
Attack();
}
private void FixedUpdate()
{
if (pState.dashing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if(Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if(attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if(yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if(yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if(pState.recoilingX)
{
if(pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if(pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if(pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if(Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
}
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
Afterwards, remember to assign the Blood Spurt prefab onto the Player Controller, or the blood splurt effect won’t show!
ii. Slow down TimeScale when Player is hit
Next, we will add a function to slow down the time scale when the player is hit. This mechanic is quite common in games of this nature as it allows the player some time to recover after being attacked.
Let’s begin by adding a bool restoreTime and a float restoreTimeSpeed in the PlayerController. Then, we will create a function HitStopTime() that takes 3 arguments: float _newTimeScale, int _restoreSpeed, and float _delay.
Firstly, we will set restoreTimeSpeed to _restoreSpeed, allowing the restoration speed to vary depending on the enemy attacking the player. Then, we will set the timescale to _newTimeScale.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
Flip();
Move();
Jump();
StartDash();
Attack();
}
private void FixedUpdate()
{
if (pState.dashing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
Time.timeScale = _newTimeScale;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
}
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
Next, we need to create a Coroutine StartTimeAgain() with an argument: float _delay. Within this Coroutine, we’ll call a WaitForSecondsRealtime() and then we’ll set restoreTime to true. In HitStopTime(), if _delay is greater than 0 (indicating that the player has been attacked), we will call the StartTimeAgain() coroutine. To prevent stacking of the function if the player is attacked multiple times, we will stop the StartTimeAgain() coroutine before starting it again. Otherwise, we will set restoreTime to true.
Now, let’s create another function RestoreTimeScale() that will restore the timescale to normal. Firstly, we will check if restoreTime is true. If it is, we will check if the timescale is less than 1. If so, we will increase the timescale using Time.unscaledDeltaTime. Otherwise, set the timescale to 1 and reset restoreTime to false. This ensures that if the timescale is less than 1, it will gradually increase until it reaches 1. If it exceeds 1, it will be reset back to 1. Finally, we will call RestoreTimeScale() in Update().
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
<mark class="green">bool restoreTime;
float restoreTimeSpeed;</mark>
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
Flip();
Move();
Jump();
StartDash();
Attack();
RestoreTimeScale();
}
private void FixedUpdate()
{
if (pState.dashing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
}
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
We will invoke this slow time mechanic in the Enemy script after the enemy attacks the player.
Enemy.cs
public class Enemy : MonoBehaviour
{
[SerializeField] protected float health;
[SerializeField] protected float recoilLength;
[SerializeField] protected float recoilFactor;
[SerializeField] protected bool isRecoiling = false;
[SerializeField] protected float speed;
[SerializeField] protected float damage;
protected float recoilTimer;
protected Rigidbody2D rb;
// Start is called before the first frame update
protected virtual void Start()
{
rb = GetComponent<Rigidbody2D>();
}
// Update is called once per frame
protected virtual void Update()
{
if(health <= 0)
{
Destroy(gameObject);
}
if(isRecoiling)
{
if(recoilTimer < recoilLength)
{
recoilTimer += Time.deltaTime;
}
else
{
isRecoiling = false;
recoilTimer = 0;
}
}
}
public virtual void EnemyHit(float _damageDone, Vector2 _hitDirection, float _hitForce)
{
health -= _damageDone;
if(!isRecoiling)
{
rb.AddForce(-_hitForce * recoilFactor * _hitDirection);
isRecoiling = True;
}
}
protected void OnTriggerStay2D(Collider2D _other)
{
if(_other.CompareTag("Player") && !PlayerController.Instance.pState.invincible)
{
Attack();
PlayerController.Instance.HitStopTime(0, 5, 0.5f);
}
}
protected virtual void Attack()
{
PlayerController.Instance.TakeDamage(damage);
}
}
iii. Flash Effect when Player is invincible
Lastly, we will add a flash effect when the player is invincible so that it’s clear that they are invincible.
In the PlayerController script, let’s create a float hitFlashSpeed and SpriteRenderer sr. Assign the SpriteRenderer in void Start(), then, we will create a function FlashWhileInvincible() that changes the sprite renderer’s color to ping-pong between white and black if the player is invincible. The “ping-pong”-ing alternates the color between white and black continuously as long as the specified parameters are met. If the player is not invincible, we will set the player’s color to white. Finally, we will add this function to the Update() function. Remember to set a value for hitFlashSpeed in your Inspector.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[SerializeField] float hitFlashSpeed;
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
private SpriteRenderer sr;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
Flip();
Move();
Jump();
StartDash();
Attack();
RestoreTimeScale();
FlashWhileInvincible();
}
private void FixedUpdate()
{
if (pState.dashing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
}
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
3. Hearts UI system
a. Setting up the script
Okay, now we will proceed to add some hearts to visually represent the player’s health. Start by creating a Canvas by Right-Clicking > UI > Canvas. Set the Canvas to scale with the screen size. Next, we will create a script HeartController on the Canvas Prefab.
In the HeartController script, let’s add using UnityEngine.UI to the namespace. Now, we will add the following variables: private GameObject[] heartContainers, private Image[] heartFills, public Transform heartsParent, and public GameObject heartContainerPrefab. The heartContainers[] array will serve as a container to hold the images of the filled hearts.
HeartController.cs
using UnityEngine.UI;
public class HeartController : MonoBehaviour
{
private GameObject[] heartContainers;
private Image[] heartFills;
public Transform heartsParent;
public GameObject heartContainerPrefab;
// Start is called before the first frame update
void Start()
{
}
// Update is called once per frame
void Update()
{
}
}
b. Creating the UI elements
Before we proceed, let’s create the heart container prefab first. We will be using these heart-container and heart-fill images, which you can find here.
Lets create the Heart prefab:
- Set both images to Clamp and Point, No Filter.
- Drag out both the heart container image and the heart fill image.
- Make the fill image a child of the container image and set its transform to 0 for all values, including the transform position.
- Rename this object to Heart Container.
- Drag the Heart Container into the Prefabs folder.
Now, let’s make some modifications to the Heart Container prefab, because we made it as a regular GameObject. For it to be able to show up as a UI element, we will need to use components that work properly with Unity’s Canvas GameObject:
- Remove the Sprite Renderer from both the container and the fill objects.
- Add an Image component to both of them (notice that the Transform becomes a Rect Transform when you do that; this is important!).
- Assign the respective sprites to the source image in each component.
- Resize the heart container to 40 x 40 pixels and check Preserve Aspect.
- Change the image type of the fill to Filled.
- Uncheck Clockwise.
Next up, we’ll edit the Canvas and create the parent object for our hearts:
- Create an empty GameObject and name it HeartsParent. Make sure that it is added to the Canvas GameObject.
- Add a Grid Layout Group component to it
- Set the cell size to 40 pixels for both width and height and set the spacing to 1 for both.
- Change the child alignment to Middle Left and set the constraints to Fixed Row Count with a count of 1.
c. Coding the UI
How many hearts we will need will be determined on the player’s maximum health. We will create a function SetHeartContainers() which will determine and spawn in how many heartContainers[] we will need in the scene. We will iterate through the heartContainers[] array to determine how many hearts should be displayed.
We will then create a function SetFilledHearts(), which will do the same but for the heartFills[] instead.
Next, we will create another function InstantiateHeartContainers() which will determine how many of the heartContainerPrefabs will be instantiated. Once again, we will iterate through the maxHealth value to determine that. We will then set the parent of the instantiated heartContainerPrefab to the heartsParent transform and position it accordingly. Lastly, we will set heartFills[i] to the Image component within the heartFill[i] object so the heartFills[] will deactivate according to the current Health value.
HeartController.cs
using UnityEngine.UI;
public class HeartController : MonoBehaviour
{
private GameObject[] heartContainers;
private Image[] heartFills;
public Transform heartsParent;
public GameObject heartContainerPrefab;
// Start is called before the first frame update
void Start()
{
heartContainers = new GameObject[PlayerController.Instance.maxHealth];
heartFills = new Image[PlayerController.Instance.maxHealth];
}
// Update is called once per frame
void Update()
{
}
void SetHeartContainers()
{
for(int i = 0; i < heartContainers.Length; i++)
{
if(i < PlayerController.Instance.maxHealth)
{
heartContainers[i].SetActive(true);
}
else
{
heartContainers[i].SetActive(false);
}
}
}
void SetFilledHearts()
{
for (int i = 0; i < heartFills.Length; i++)
{
if (i < PlayerController.Instance.Health)
{
heartFills[i].fillAmount = 1;
}
else
{
heartFills[i].fillAmount = 0;
}
}
}
void InstantiateHeartContainers()
{
for(int i = 0; i < PlayerController.Instance.maxHealth; i++)
{
GameObject temp = Instantiate(heartContainerPrefab);
temp.transform.SetParent(heartsParent, false);
heartContainers[i] = temp;
heartFills[i] = temp.transform.Find("HeartFill").GetComponent<Image>();
}
}
}
Note that for the temp.transform.Find("HeartFill") portion, make sure that the string within Find() has the same name as the sprite in your project folder. For example, if your sprite is named "Hearts", then you would use temp.transform.Find("Hearts") instead.
Alright, there’s one more task we need to complete before testing it out. we’ll be updating the hearts when the player gets attacked.
In the HeartController, let’s create a function UpdateHeartsHUD() with the SetHeartContainers() and SetFilledHearts() inside it. Also, we’ll call UpdateHeartsHUD() and InstantiateHeartContainers() in void Start().
HeartController.cs
using UnityEngine.UI;
public class HeartController : MonoBehaviour
{
private GameObject[] heartContainers;
private Image[] heartFills;
public Transform heartsParent;
public GameObject heartContainerPrefab;
// Start is called before the first frame update
void Start()
{
heartContainers = new GameObject[PlayerController.Instance.maxHealth];
heartFills = new Image[PlayerController.Instance.maxHealth];
InstantiateHeartContainers();
UpdateHeartsHUD();
}
// Update is called once per frame
void Update()
{
}
void SetHeartContainers()
{
for(int i = 0; i < heartContainers.Length; i++)
{
if(i < PlayerController.Instance.maxHealth)
{
heartContainers[i].SetActive(true);
}
else
{
heartContainers[i].SetActive(false);
}
}
}
void SetFilledHearts()
{
for (int i = 0; i < heartFills.Length; i++)
{
if (i < PlayerController.Instance.Health)
{
heartFills[i].fillAmount = 1;
}
else
{
heartFills[i].fillAmount = 0;
}
}
}
void InstantiateHeartContainers()
{
for(int i = 0; i < PlayerController.Instance.maxHealth; i++)
{
GameObject temp = Instantiate(heartContainerPrefab);
temp.transform.SetParent(heartsParent, false);
heartContainers[i] = temp;
heartFills[i] = temp.transform.Find("HeartFill").GetComponent<Image>();
}
}
void UpdateHeartsHUD()
{
SetHeartContainers();
SetFilledHearts();
}
}
Now, go back to the PlayerController and create a delegate void OnHealthChangedDelegate() with a variable name onHealthChangedCallback. This delegate will be responsible for any necessary updates related to the hearts. Using a delegate allows us to call multiple methods. We will use the same delegate not only to decrease the hearts but also to increase them if needed.
Inside the Health property, we will invoke the onHealthChangedCallback delegate.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[SerializeField] float hitFlashSpeed;
public delegate void OnHealthChangedDelegate();
[HideInInspector] public OnHealthChangedDelegate onHealthChangedCallback;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
private SpriteRenderer sr;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
Flip();
Move();
Jump();
StartDash();
Attack();
RestoreTimeScale();
FlashWhileInvincible();
}
private void FixedUpdate()
{
if (pState.dashing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
if (onHealthChangedCallback != null)
{
onHealthChangedCallback.Invoke();
}
}
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
Now, back in the HeartController, we will call the onHealthChangedCallback delegate using “+=” and attach UpdateHeartsHUD(). We are using “+=” to multicast the delegate, allowing multiple functions to run simultaneously when we call this delegate.
HeartController.cs
using UnityEngine.UI;
public class HeartController : MonoBehaviour
{
private GameObject[] heartContainers;
private Image[] heartFills;
public Transform heartsParent;
public GameObject heartContainerPrefab;
// Start is called before the first frame update
void Start()
{
heartContainers = new GameObject[PlayerController.Instance.maxHealth];
heartFills = new Image[PlayerController.Instance.maxHealth];
PlayerController.Instance.onHealthChangedCallback += UpdateHeartsHUD;
InstantiateHeartContainers();
UpdateHeartsHUD();
}
// Update is called once per frame
void Update()
{
}
void SetHeartContainers()
{
for(int i = 0; i < heartContainers.Length; i++)
{
if(i < PlayerController.Instance.maxHealth)
{
heartContainers[i].SetActive(true);
}
else
{
heartContainers[i].SetActive(false);
}
}
}
void SetFilledHearts()
{
for (int i = 0; i < heartFills.Length; i++)
{
if (i < PlayerController.Instance.Health)
{
heartFills[i].fillAmount = 1;
}
else
{
heartFills[i].fillAmount = 0;
}
}
}
void InstantiateHeartContainers()
{
for(int i = 0; i < PlayerController.Instance.maxHealth; i++)
{
GameObject temp = Instantiate(heartContainerPrefab);
temp.transform.SetParent(heartsParent, false);
heartContainers[i] = temp;
heartFills[i] = temp.transform.Find("HeartFill").GetComponent<Image>();
}
}
void UpdateHeartsHUD()
{
SetHeartContainers();
SetFilledHearts();
}
}
At this point, if we test it out, the hearts should spawn in and decrease if the player gets attacked.
4. Player healing
a. Coding the healing mechanic
Currently, the Health can decrease. Next, we’ll introduce a healing mechanic to allow the player to recover after a challenging battle or accidental fall damage.
Firstly, in the Input Manager, we’ll change “Fire2” to “Healing“. Let’s assign the right mouse button (Mouse 1) for this action.
Then, in the PlayerStateList, we’ll add a bool healing.
PlayerStateList.cs
public class PlayerStateList : MonoBehaviour
{
public bool jumping = false;
public bool dashing = false;
public bool recoilingX, recoilingY;
public bool lookingRight;
public bool invincible;
public bool healing;
}
Next, in the PlayerController, we’ll create a float healTimer and a Serialized float timeToHeal. These variables, similar to the invincibility mechanic, will regulate the healing speed to prevent it from occurring every frame and potentially becoming overpowered.
Alright, let’s proceed by creating a function Heal(). If the player inputs the “Healing” command, their Health is below the maximum value, and is idle & grounded, we’ll set pstate.healing to true. Otherwise, we set it to false. Then, we increment the healTimer. If it becomes greater than or equal to timeToHeal, we increase the Health by 1 and reset the healTimer back to 0.
In the else statement, we also reset the healTimer to 0, ensuring that the healing process restarts if the player stops the healing input. Finally, we will move the methods in Update() that should not be able to function while pstate.healing is true under an if statement checking for healing. Then, we add Heal() to void Update(). We’ll also add an if statement in Move() to stop the player’s velocity while healing. Additionally, in our FixedUpdate(), add the pstate.healing as part of the if statement’s parameters.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[SerializeField] float hitFlashSpeed;
public delegate void OnHealthChangedDelegate();
[HideInInspector] public OnHealthChangedDelegate onHealthChangedCallback;
float healTimer;
[SerializeField] float timeToHeal;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
private SpriteRenderer sr;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
RestoreTimeScale();
FlashWhileInvincible();
Move();
Heal();
if (pState.healing) return;
Flip();
Jump();
StartDash();
Attack();
}
private void FixedUpdate()
{
if (pState.dashing || pState.healing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
if (pState.healing) rb.velocity = new Vector2(0, 0);
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
if (onHealthChangedCallback != null)
{
onHealthChangedCallback.Invoke();
}
}
}
}
void Heal()
{
if (Input.GetButton("Healing") && Health < maxHealth && Grounded() && !pState.dashing)
{
pState.healing = true;
//healing
healTimer += Time.deltaTime;
if (healTimer >= timeToHeal)
{
Health++;
healTimer = 0;
}
}
else
{
pState.healing = false;
healTimer = 0;
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
b. Creating a healing animation
Let’s also create a healing animation. Create an animation clip and name it Player_Heal. We’ll use the crouch sprites for this animation since we won’t have player crouching.
Next up, we’ll do the following:
- Uncheck the Loop Time.
- In the Animator, link the healing animation to the Player_Idle.
- Create a bool healing and add it to both the entry and exit arrows.
- Set healing to true for the arrow leading towards Player_Heal and false for the arrow leading away from Player_Heal.
- Disable Has Exit Time and set the Transition Duration to 0.
Now, in the Heal() function, we’ll activate the healing animation by setting the bool healing to true.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[SerializeField] float hitFlashSpeed;
public delegate void OnHealthChangedDelegate();
[HideInInspector] public OnHealthChangedDelegate onHealthChangedCallback;
float healTimer;
[SerializeField] float timeToHeal;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
private SpriteRenderer sr;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
RestoreTimeScale();
FlashWhileInvincible();
Move();
Heal();
if (pState.healing) return;
Flip();
Jump();
StartDash();
Attack();
}
private void FixedUpdate()
{
if (pState.dashing || pState.healing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
if (pState.healing) rb.velocity = new Vector2(0, 0);
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
if (onHealthChangedCallback != null)
{
onHealthChangedCallback.Invoke();
}
}
}
}
void Heal()
{
if (Input.GetButton("Healing") && Health < maxHealth && Grounded() && !pState.dashing)
{
pState.healing = true;
anim.SetBool("Healing", true);
//healing
healTimer += Time.deltaTime;
if (healTimer >= timeToHeal)
{
Health++;
healTimer = 0;
}
}
else
{
pState.healing = false;
anim.SetBool("Healing", false);
healTimer = 0;
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
5. Player Mana
a. Reduce Mana when healing
Now that we have the healing mechanic, let’s introduce a mana mechanic to prevent infinite healing and also serve as a limitation for future spellcasting.
In the PlayerController, we’ll create a section called “Mana Settings” and add 2 Serialized floats: mana and manaDrainSpeed. We’ll set both mana and manaDrainSpeed to a suitable value of 0.5 and 0.2, respectively, in the inspector Additionally, let’s create a float property Mana that returns the mana value. After retrieving the mana value, we’ll update it if it’s different from the current value of the Mana property.
In Heal(), we’ll only allow healing if the player’s mana is greater than 0. While healing, we’ll also drain the mana. In void Start(), we’ll set the Mana property to the mana value.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[SerializeField] float hitFlashSpeed;
public delegate void OnHealthChangedDelegate();
[HideInInspector] public OnHealthChangedDelegate onHealthChangedCallback;
float healTimer;
[SerializeField] float timeToHeal;
[Space(5)]
[Header("Mana Settings")]
[SerializeField] float mana;
[SerializeField] float manaDrainSpeed;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
private SpriteRenderer sr;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
Mana = mana;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
RestoreTimeScale();
FlashWhileInvincible();
Move();
Heal();
if (pState.healing) return;
Flip();
Jump();
StartDash();
Attack();
}
private void FixedUpdate()
{
if (pState.dashing || pState.healing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
if (pState.healing) rb.velocity = new Vector2(0, 0);
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
if (onHealthChangedCallback != null)
{
onHealthChangedCallback.Invoke();
}
}
}
}
void Heal()
{
if (Input.GetButton("Healing") && Health < maxHealth && Grounded() && !pState.dashing)
{
pState.healing = true;
anim.SetBool("Healing", true);
//healing
healTimer += Time.deltaTime;
if (healTimer >= timeToHeal)
{
Health++;
healTimer = 0;
}
//drain mana
Mana -= Time.deltaTime * manaDrainSpeed;
}
else
{
pState.healing = false;
anim.SetBool("Healing", false);
healTimer = 0;
}
}
float Mana
{
get { return mana; }
set
{
//if mana stats change
if (mana != value)
{
mana = Mathf.Clamp(value, 0, 1);
}
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
b. Gain Mana when attacking enemies
Let’s now add a way to gain Mana. We’ll create a Serialized float manaGain. In the Hit() function, we’ll gain mana whenever we hit anything with the “Enemy” tag.
Since we’ve coded our mana gain to only work if the hit object is tagged as an “Enemy”, remember to tag your enemy after you modify your code!
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[SerializeField] float hitFlashSpeed;
public delegate void OnHealthChangedDelegate();
[HideInInspector] public OnHealthChangedDelegate onHealthChangedCallback;
float healTimer;
[SerializeField] float timeToHeal;
[Space(5)]
[Header("Mana Settings")]
[SerializeField] float mana;
[SerializeField] float manaDrainSpeed;
[SerializeField] float manaGain;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
private SpriteRenderer sr;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
Mana = mana;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
RestoreTimeScale();
FlashWhileInvincible();
Move();
Heal();
if (pState.healing) return;
Flip();
Jump();
StartDash();
Attack();
}
private void FixedUpdate()
{
if (pState.dashing || pState.healing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
if (pState.healing) rb.velocity = new Vector2(0, 0);
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
if (objectsToHit[i].CompareTag("Enemy"))
{
Mana += manaGain;
}
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
if (onHealthChangedCallback != null)
{
onHealthChangedCallback.Invoke();
}
}
}
}
void Heal()
{
if (Input.GetButton("Healing") && Health < maxHealth && Mana > 0 && Grounded() && !pState.dashing)
{
pState.healing = true;
anim.SetBool("Healing", true);
//healing
healTimer += Time.deltaTime;
if (healTimer >= timeToHeal)
{
Health++;
healTimer = 0;
}
//drain mana
Mana -= Time.deltaTime * manaDrainSpeed;
}
else
{
pState.healing = false;
anim.SetBool("Healing", false);
healTimer = 0;
}
}
float Mana
{
get { return mana; }
set
{
//if mana stats change
if (mana != value)
{
mana = Mathf.Clamp(value, 0, 1);
}
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
At this point, if we play, we’ll get a bug that results in doubled Mana gained. This occurs due to the presence of 2 colliders on our enemy. Consequently, when we attack, the detection happens twice, which also leads to double damage. To fix this, we will remove the smaller collider and uncheck Is Trigger for the remaining collider.
If you need to have multiple colliders on your enemies, but only have a single hit register, check out this forum topic where Terence discusses how to do it.
Additionally, in the Enemy script, we will modify OnTriggerStay2D to OnCollisionStay2D.
Enemy.cs
public class Enemy : MonoBehaviour
{
[SerializeField] protected float health;
[SerializeField] protected float recoilLength;
[SerializeField] protected float recoilFactor;
[SerializeField] protected bool isRecoiling = false;
[SerializeField] protected float speed;
[SerializeField] protected float damage;
protected float recoilTimer;
protected Rigidbody2D rb;
// Start is called before the first frame update
protected virtual void Start()
{
rb = GetComponent<Rigidbody2D>();
}
// Update is called once per frame
protected virtual void Update()
{
if(health <= 0)
{
Destroy(gameObject);
}
if(isRecoiling)
{
if(recoilTimer < recoilLength)
{
recoilTimer += Time.deltaTime;
}
else
{
isRecoiling = false;
recoilTimer = 0;
}
}
}
public virtual void EnemyHit(float _damageDone, Vector2 _hitDirection, float _hitForce)
{
health -= _damageDone;
if(!isRecoiling)
{
rb.AddForce(-_hitForce * recoilFactor * _hitDirection);
isRecoiling = True;
}
}
protected void OnTriggerStay2D OnCollisionStay2D (Collider2D Collision2D _other)
{
if(_other.gameObject.CompareTag("Player") && !PlayerController.Instance.pState.invincible)
{
Attack();
PlayerController.Instance.HitStopTime(0, 5, 0.5f);
}
}
protected virtual void Attack()
{
PlayerController.Instance.TakeDamage(damage);
}
}
c. Creating a UI to show the Mana
Next, we’ll add a UI element to display the amount of mana we have:
- Create 2 UI circle images. The circle sprites can be found here: Packages > 2D Sprite > Editor > ObjectMenuCreation > Default Assets > Textures.
- Make one slightly larger than the other and change its (the larger circle) color to black.
- Rename it (the black circle) to Mana Container.
- Then, make the white circle a child of the black circle and recentre it
- Change the Image type of the white circle to Filled and rename it to Mana.
- Shift these elements to the top left-hand corner of the Canvas.
- To prevent clashing with the mana container, shift the Hearts Area more to the right.
Alright, in the PlayerController, add a Serialized Image manaStorage. In void Start() and Mana, set the fill Amount of manaStorage to reflect the current Mana value.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[SerializeField] float hitFlashSpeed;
public delegate void OnHealthChangedDelegate();
[HideInInspector] public OnHealthChangedDelegate onHealthChangedCallback;
float healTimer;
[SerializeField] float timeToHeal;
[Space(5)]
[Header("Mana Settings")]
[SerializeField] UnityEngine.UI.Image manaStorage;
[SerializeField] float mana;
[SerializeField] float manaDrainSpeed;
[SerializeField] float manaGain;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
private SpriteRenderer sr;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
Mana = mana;
manaStorage.fillAmount = Mana;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
RestoreTimeScale();
FlashWhileInvincible();
Move();
Heal();
if (pState.healing) return;
Flip();
Jump();
StartDash();
Attack();
}
private void FixedUpdate()
{
if (pState.dashing || pState.healing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
if (pState.healing) rb.velocity = new Vector2(0, 0);
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
if (objectsToHit[i].CompareTag("Enemy"))
{
Mana += manaGain;
}
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
if (onHealthChangedCallback != null)
{
onHealthChangedCallback.Invoke();
}
}
}
}
void Heal()
{
if (Input.GetButton("Healing") && Health < maxHealth && Mana > 0 && Grounded() && !pState.dashing)
{
pState.healing = true;
anim.SetBool("Healing", true);
//healing
healTimer += Time.deltaTime;
if (healTimer >= timeToHeal)
{
Health++;
healTimer = 0;
}
//drain mana
Mana -= Time.deltaTime * manaDrainSpeed;
}
else
{
pState.healing = false;
anim.SetBool("Healing", false);
healTimer = 0;
}
}
float Mana
{
get { return mana; }
set
{
//if mana stats change
if (mana != value)
{
mana = Mathf.Clamp(value, 0, 1);
manaStorage.fillAmount = Mana;
}
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
6. Spellcasting
Moving on, we will now create a set of offensive spells that the player can use during the game. Taking inspiration from Hollow Knight, we will replicate the feature where the spells cast change depending on the casting direction.
Firstly, in the input manager, we will replace “Fire3” with “CastSpell” and use the F key for that purpose.
a. Creating the Spells
i. Creating the Side Spell
For the side cast, we will replicate the Vengeful Spirit with a fireball. Let’s use the fireball sprites from the knight pack.
Let’s create the Fireball:
- Drag out a fireball sprite and name it Fireball
- create an animation clip named Fireball.
- Drag in the sprites and adjust the keyframes to achieve the desired effect.
- add a BoxCollider2D to the fireball and set it as a Trigger.
- Now, let’s create a script called
FireBalland add it to the Fireball
In the FireBall script, we will define several variables: float damage, float hitForce (since we don’t want the hit force to be the same as the normal melee hit force), int speed, float lifeTime. We will set the default value of lifeTime to 1.
In void Start(), we will destroy the Fireball GameObject after the lifeTime has passed. Next, we will create a FixedUpdate() to move the Fireball. And finally, we will implement an OnTriggerEnter2D() to detect if the Fireball hits an enemy. If a collision occurs, we will deal damage to the enemy.
FireBall.cs
public class FireBall : MonoBehaviour
{
[SerializeField] float damage;
[SerializeField] float hitForce;
[SerializeField] int speed;
[SerializeField] float lifetime = 1;
// Start is called before the first frame update
void Start()
{
Destroy(gameObject, lifetime);
}
private void FixedUpdate()
{
transform.position += speed * transform.right;
}
//detect hit
private void OnTriggerEnter2D(Collider2D _other)
{
if(_other.tag == "Enemy")
{
_other.GetComponent<Enemy>().EnemyHit(damage, (_other.transform.position - transform.position).normalized, -hitForce);
}
}
}
Finally, make the Fireball a prefab and reset its transform position values to (0, 0, 0) and delete it from the scene.
ii. Creating the Downward Spell
Next, we will recreate the Desolate Dive spell, we will displaying a massive fireball and force the player downwards during the spellcast:
- Start by dragging in a fireball sprite and renaming it to Down Spell Fireball.
- Set the rotation to -90 and scale it to 10.
- Add a CircleCollider2D and adjust it to cover only the main body of the fireball.
- Set this collider as a Trigger.
- Attach the Animator component to the fireball and assign the previously made Fireball controller to it.
Make the Down Spell Fireball a child of the player and reposition it to the centre (you may want to increase its Y position such that the player is in the centre of the main body of the fireball).
Disable the Game Object, we will enable it when the Desolate Dive spell is cast.
iii. Creating the Upward Spell
Lastly, let’s implement the Howling Wraiths spell.
Fortunately, the knight pack includes an explosion sprite that we can use. Start by dragging out the explosion sprite and naming it Up Spell Explosion. Create an animation called Explosion.
Once the animation is created, we’ll do the following:
- Add a BoxCollider2D to the Up Spell Explosion.
- Set it as a trigger and adjust the Y offset to -0.16 to ensure proper positioning.
- Make the Up Spell Explosion a prefab.
- Recentre the Up Spell Explosion, but increase the Y position as the explosion is supposed to occur above the player. I recommend using a value of 1.5 (but feel free to experiment with different values.)
- Adjust the scale to 10
- Attach the
DestroyAfterAnimationscript to the Up Spell Explosion.
DestroyAfterAnimation scriptb. Creating the Spellcasting animation
Next up, we will create the cast spell animation:
- Create an animation clip called Player_Cast.
- Drag in the cast sprites from the knight pack.
- Uncheck Loop Time.
- In the Animator window, link Player_Cast to the idle, jump, and walk animations.
- Create a bool Casting and add it to the transitions.
- Set Casting to true for the arrows leading towards Player_Cast and set it to false for the arrows leading away from it.
- Uncheck Has Exit Time and set the Transition Duration to 0.
c. Coding the Spellcasting
Alright, let’s finally move on to actually coding the spells
Firstly, in the PlayerStateList, create a bool casting.
PlayerStateList.cs
public class PlayerStateList : MonoBehaviour
{
public bool jumping = false;
public bool dashing = false;
public bool recoilingX, recoilingY;
public bool lookingRight;
public bool invincible;
public bool healing;
public bool casting;
}
Now, in the PlayerController, let’s add a section for Spellcasting. We’ll define a float manaSpellCost and set its default value to 0.3. This means that with full mana, we can cast only 3 spells before running out. Additionally, include a float timeBetweenCasts and float timeSinceCast to prevent spamming. Let’s set the default value of timeSinceCast to 0.5 seconds. Next, create GameObjects sideSpellFireball, upSpellExplosion and downSpellFireball. We’ll also include a float spellDamage, which will be used specifically for Howling Wraiths and Desolate Dive spells. Lastly, add a float downSpellForce to determine the downward force applied to the player when using the Desolate Dive.
With the setup complete, let’s create the CastSpell() function. Inside this function, check if the player inputs Castspell and if timeSinceCast is greater than or equal to timeBetweenCast AND there is sufficient Mana. If these conditions are met, set pState.casting to true and reset timeSinceCast to 0. Otherwise, increment timeSinceCast.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[SerializeField] float hitFlashSpeed;
public delegate void OnHealthChangedDelegate();
[HideInInspector] public OnHealthChangedDelegate onHealthChangedCallback;
float healTimer;
[SerializeField] float timeToHeal;
[Space(5)]
[Header("Mana Settings")]
[SerializeField] UnityEngine.UI.Image manaStorage;
[SerializeField] float mana;
[SerializeField] float manaDrainSpeed;
[SerializeField] float manaGain;
[Space(5)]
[Header("Spell Settings")]
//spell stats
[SerializeField] float manaSpellCost = 0.3f;
[SerializeField] float timeBetweenCast = 0.5f;
float timeSinceCast;
[SerializeField] float spellDamage; //upspellexplosion and downspellfireball
[SerializeField] float downSpellForce; // desolate dive only
//spell cast objects
[SerializeField] GameObject sideSpellFireball;
[SerializeField] GameObject upSpellExplosion;
[SerializeField] GameObject downSpellFireball;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
private SpriteRenderer sr;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
Mana = mana;
manaStorage.fillAmount = Mana;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
RestoreTimeScale();
FlashWhileInvincible();
Move();
Heal();
if (pState.healing) return;
Flip();
Jump();
StartDash();
Attack();
}
private void FixedUpdate()
{
if (pState.dashing || pState.healing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
if (pState.healing) rb.velocity = new Vector2(0, 0);
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
if (objectsToHit[i].CompareTag("Enemy"))
{
Mana += manaGain;
}
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
if (onHealthChangedCallback != null)
{
onHealthChangedCallback.Invoke();
}
}
}
}
void Heal()
{
if (Input.GetButton("Healing") && Health < maxHealth && Mana > 0 && Grounded() && !pState.dashing)
{
pState.healing = true;
anim.SetBool("Healing", true);
//healing
healTimer += Time.deltaTime;
if (healTimer >= timeToHeal)
{
Health++;
healTimer = 0;
}
//drain mana
Mana -= Time.deltaTime * manaDrainSpeed;
}
else
{
pState.healing = false;
anim.SetBool("Healing", false);
healTimer = 0;
}
}
float Mana
{
get { return mana; }
set
{
//if mana stats change
if (mana != value)
{
mana = Mathf.Clamp(value, 0, 1);
manaStorage.fillAmount = Mana;
}
}
}
void CastSpell()
{
if (Input.GetButtonDown("CastSpell") && timeSinceCast >= timeBetweenCast && Mana >= manaSpellCost)
{
pState.casting = true;
timeSinceCast = 0;
StartCoroutine(CastCoroutine());
}
else
{
timeSinceCast += Time.deltaTime;
}
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
Since we call a function CastCoroutine(), adding the code mentioned above will cause an error to show on it. Hence, let’s create the CastCoroutine() function as well. First, play the animation and then use WaitForSeconds(). Since the animation consists of two parts, the preparation phase and the casting phase, we only want the spells to cast when it reaches the casting phase. If the animation you have is identical to mine, this occurs 0.15 seconds after the animation plays, so that will be the value we use in the WaitForSeconds().
Now, let’s create the different spells. For the side spell, cast it only if there is no vertical input or if the player is grounded and holding the S key, similar to the side attack. Create a GameObject variable _fireBall and instantiate it at the sideAttackTransform position. If the player is not facing right, flip the fireball so that it moves towards the left. Finally, make the player recoil.
Moving on to the upward spell, instantiate the upSpellExplosion at the player’s transform if they are holding the W key. Set the player’s velocity to 0 to freeze them in place during the spellcast.
Lastly, for the downward spell, if the player is holding the down S key and is not grounded, enable the downSpellFireball. After casting the spell, decrease the Mana by the cost.
After the spells are cast, Use WaitForSeconds() again, The value of this WaitForSeconds() represents the time from the cast to the end of the animation, so adjust it according to your animation if necessary. Then, set the animation to false and pstate.casting to false as well.
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[SerializeField] float hitFlashSpeed;
public delegate void OnHealthChangedDelegate();
[HideInInspector] public OnHealthChangedDelegate onHealthChangedCallback;
float healTimer;
[SerializeField] float timeToHeal;
[Space(5)]
[Header("Mana Settings")]
[SerializeField] UnityEngine.UI.Image manaStorage;
[SerializeField] float mana;
[SerializeField] float manaDrainSpeed;
[SerializeField] float manaGain;
[Space(5)]
[Header("Spell Settings")]
//spell stats
[SerializeField] float manaSpellCost = 0.3f;
[SerializeField] float timeBetweenCast = 0.5f;
float timeSinceCast;
[SerializeField] float spellDamage; //upspellexplosion and downspellfireball
[SerializeField] float downSpellForce; // desolate dive only
//spell cast objects
[SerializeField] GameObject sideSpellFireball;
[SerializeField] GameObject upSpellExplosion;
[SerializeField] GameObject downSpellFireball;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
private SpriteRenderer sr;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
Mana = mana;
manaStorage.fillAmount = Mana;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
RestoreTimeScale();
FlashWhileInvincible();
Move();
Heal();
if (pState.healing) return;
Flip();
Jump();
StartDash();
Attack();
}
private void FixedUpdate()
{
if (pState.dashing || pState.healing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
if (pState.healing) rb.velocity = new Vector2(0, 0);
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
if (objectsToHit[i].CompareTag("Enemy"))
{
Mana += manaGain;
}
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
if (onHealthChangedCallback != null)
{
onHealthChangedCallback.Invoke();
}
}
}
}
void Heal()
{
if (Input.GetButton("Healing") && Health < maxHealth && Mana > 0 && Grounded() && !pState.dashing)
{
pState.healing = true;
anim.SetBool("Healing", true);
//healing
healTimer += Time.deltaTime;
if (healTimer >= timeToHeal)
{
Health++;
healTimer = 0;
}
//drain mana
Mana -= Time.deltaTime * manaDrainSpeed;
}
else
{
pState.healing = false;
anim.SetBool("Healing", false);
healTimer = 0;
}
}
float Mana
{
get { return mana; }
set
{
//if mana stats change
if (mana != value)
{
mana = Mathf.Clamp(value, 0, 1);
manaStorage.fillAmount = Mana;
}
}
}
void CastSpell()
{
if (Input.GetButtonDown("CastSpell") && timeSinceCast >= timeBetweenCast && Mana >= manaSpellCost)
{
pState.casting = true;
timeSinceCast = 0;
StartCoroutine(CastCoroutine());
}
else
{
timeSinceCast += Time.deltaTime;
}
}
IEnumerator CastCoroutine()
{
anim.SetBool("Casting", true);
yield return new WaitForSeconds(0.15f);
//side cast
if (yAxis == 0 || (yAxis < 0 && Grounded()))
{
GameObject _fireBall = Instantiate(sideSpellFireball, SideAttackTransform.position, Quaternion.identity);
//flip fireball
if(pState.lookingRight)
{
_fireBall.transform.eulerAngles = Vector3.zero; // if facing right, fireball continues as per normal
}
else
{
_fireBall.transform.eulerAngles = new Vector2(_fireBall.transform.eulerAngles.x, 180);
//if not facing right, rotate the fireball 180 deg
}
pState.recoilingX = true;
}
//up cast
else if( yAxis > 0)
{
Instantiate(upSpellExplosion, transform);
rb.velocity = Vector2.zero;
}
//down cast
else if(yAxis < 0 && !Grounded())
{
downSpellFireball.SetActive(true);
}
Mana -= manaSpellCost;
yield return new WaitForSeconds(0.35f);
anim.SetBool("Casting", false);
pState.casting = false;
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
In the CastSpell() function, add the CastCoroutine() after setting timeSinceCast to 0. Additionally, disable the downSpellFireball if the player is grounded. However, if it is active, apply a downward force of downSpellForce to the player. Afterwards, we will create an OnTriggerEnter2D function that deals damage to the enemy if they are within the trigger collider of the spell. Finally, include the CastSpell() function in void update().
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[SerializeField] float hitFlashSpeed;
public delegate void OnHealthChangedDelegate();
[HideInInspector] public OnHealthChangedDelegate onHealthChangedCallback;
float healTimer;
[SerializeField] float timeToHeal;
[Space(5)]
[Header("Mana Settings")]
[SerializeField] UnityEngine.UI.Image manaStorage;
[SerializeField] float mana;
[SerializeField] float manaDrainSpeed;
[SerializeField] float manaGain;
[Space(5)]
[Header("Spell Settings")]
//spell stats
[SerializeField] float manaSpellCost = 0.3f;
[SerializeField] float timeBetweenCast = 0.5f;
float timeSinceCast;
[SerializeField] float spellDamage; //upspellexplosion and downspellfireball
[SerializeField] float downSpellForce; // desolate dive only
//spell cast objects
[SerializeField] GameObject sideSpellFireball;
[SerializeField] GameObject upSpellExplosion;
[SerializeField] GameObject downSpellFireball;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
private SpriteRenderer sr;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
Mana = mana;
manaStorage.fillAmount = Mana;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
RestoreTimeScale();
FlashWhileInvincible();
Move();
Heal();
CastSpell();
if (pState.healing) return;
Flip();
Jump();
StartDash();
Attack();
}
private void OnTriggerEnter2D(Collider2D _other) //for up and down cast spell
{
if(_other.GetComponent<Enemy>() != null && pState.casting)
{
_other.GetComponent<Enemy>().EnemyHit(spellDamage, (_other.transform.position - transform.position).normalized, -recoilYSpeed);
}
}
private void FixedUpdate()
{
if (pState.dashing || pState.healing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
if (pState.healing) rb.velocity = new Vector2(0, 0);
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
if (objectsToHit[i].CompareTag("Enemy"))
{
Mana += manaGain;
}
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
if (onHealthChangedCallback != null)
{
onHealthChangedCallback.Invoke();
}
}
}
}
void Heal()
{
if (Input.GetButton("Healing") && Health < maxHealth && Mana > 0 && Grounded() && !pState.dashing)
{
pState.healing = true;
anim.SetBool("Healing", true);
//healing
healTimer += Time.deltaTime;
if (healTimer >= timeToHeal)
{
Health++;
healTimer = 0;
}
//drain mana
Mana -= Time.deltaTime * manaDrainSpeed;
}
else
{
pState.healing = false;
anim.SetBool("Healing", false);
healTimer = 0;
}
}
float Mana
{
get { return mana; }
set
{
//if mana stats change
if (mana != value)
{
mana = Mathf.Clamp(value, 0, 1);
manaStorage.fillAmount = Mana;
}
}
}
void CastSpell()
{
if (Input.GetButtonDown("CastSpell") && timeSinceCast >= timeBetweenCast && Mana >= manaSpellCost)
{
pState.casting = true;
timeSinceCast = 0;
StartCoroutine(CastCoroutine());
}
else
{
timeSinceCast += Time.deltaTime;
}
if(Grounded())
{
//disable downspell if on the ground
downSpellFireball.SetActive(false);
}
//if down spell is active, force player down until grounded
if(downSpellFireball.activeInHierarchy)
{
rb.velocity += downSpellForce * Vector2.down;
}
}
IEnumerator CastCoroutine()
{
anim.SetBool("Casting", true);
yield return new WaitForSeconds(0.15f);
//side cast
if (yAxis == 0 || (yAxis < 0 && Grounded()))
{
GameObject _fireBall = Instantiate(sideSpellFireball, SideAttackTransform.position, Quaternion.identity);
//flip fireball
if(pState.lookingRight)
{
_fireBall.transform.eulerAngles = Vector3.zero; // if facing right, fireball continues as per normal
}
else
{
_fireBall.transform.eulerAngles = new Vector2(_fireBall.transform.eulerAngles.x, 180);
//if not facing right, rotate the fireball 180 deg
}
pState.recoilingX = true;
}
//up cast
else if( yAxis > 0)
{
Instantiate(upSpellExplosion, transform);
rb.velocity = Vector2.zero;
}
//down cast
else if(yAxis < 0 && !Grounded())
{
downSpellFireball.SetActive(true);
}
Mana -= manaSpellCost;
yield return new WaitForSeconds(0.35f);
anim.SetBool("Casting", false);
pState.casting = false;
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
Remember to assign the side, up & down spells and the other necessary or missing values in the Inspector before testing it out.
7. Wrap up
Before concluding, let’s organize the project files by shifting all the scripts we created today to the Scripts folder. Additionally, we’ll create a Spell Animations folder inside the Animations folder and move all the spell animations there.
8. Conclusion
That’s all I have for you in this part. In the next part, We’ll be covering perspective camera for background, building basic levels and how to transition between them. Thank you for reading till the end and I hope you’ve enjoyed the article. You can also download the project files of whatever we have done for this series so far.
If you enjoyed this article and would like to support us, please consider becoming a Patron. As a Patron, you’ll gain access to project files for our tutorials and receive exclusive posts on our blog. Your support means a lot to us, as it helps us to sustain our content creation efforts. Currently, we’re earning only 20 cents on every dollar we invest in creating content, so your patronage would go a long way in helping us to continue making high-quality tutorials.
If you feel that you’ve encountered an issue while following this tutorial you can check if it relates to any of the common issues experienced in this post. If you find that you have a different or unique problem, please create a forum post here for further assistance on the matter.
Here are the final end results of all scripts we have worked with today:
PlayerController.cs
public class PlayerController : MonoBehaviour
{
[Header("Horizontal Movement Settings:")]
[SerializeField] private float walkSpeed = 1; //sets the players movement speed on the ground
[Space(5)]
[Header("Vertical Movement Settings")]
[SerializeField] private float jumpForce = 45f; //sets how hight the player can jump
private float jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private float jumpBufferFrames; //sets the max amount of frames the jump buffer input is stored
private float coyoteTimeCounter = 0; //stores the Grounded() bool
[SerializeField] private float coyoteTime; //sets the max amount of frames the Grounded() bool is stored
private int airJumpCounter = 0; //keeps track of how many times the player has jumped in the air
[SerializeField] private int maxAirJumps; //the max no. of air jumps
private float gravity; //stores the gravity scale at start
[Space(5)]
[Header("Ground Check Settings:")]
[SerializeField] private Transform groundCheckPoint; //point at which ground check happens
[SerializeField] private float groundCheckY = 0.2f; //how far down from ground chekc point is Grounded() checked
[SerializeField] private float groundCheckX = 0.5f; //how far horizontally from ground chekc point to the edge of the player is
[SerializeField] private LayerMask whatIsGround; //sets the ground layer
[Space(5)]
[Header("Dash Settings")]
[SerializeField] private float dashSpeed; //speed of the dash
[SerializeField] private float dashTime; //amount of time spent dashing
[SerializeField] private float dashCooldown; //amount of time between dashes
[SerializeField] GameObject dashEffect;
private bool canDash = true, dashed;
[Space(5)]
[Header("Attack Settings:")]
[SerializeField] private Transform SideAttackTransform; //the middle of the side attack area
[SerializeField] private Vector2 SideAttackArea; //how large the area of side attack is
[SerializeField] private Transform UpAttackTransform; //the middle of the up attack area
[SerializeField] private Vector2 UpAttackArea; //how large the area of side attack is
[SerializeField] private Transform DownAttackTransform; //the middle of the down attack area
[SerializeField] private Vector2 DownAttackArea; //how large the area of down attack is
[SerializeField] private LayerMask attackableLayer; //the layer the player can attack and recoil off of
[SerializeField] private float timeBetweenAttack;
private float timeSinceAttack;
[SerializeField] private float damage; //the damage the player does to an enemy
[SerializeField] private GameObject slashEffect; //the effect of the slashs
bool restoreTime;
float restoreTimeSpeed;
[Space(5)]
[Header("Recoil Settings:")]
[SerializeField] private int recoilXSteps = 5; //how many FixedUpdates() the player recoils horizontally for
[SerializeField] private int recoilYSteps = 5; //how many FixedUpdates() the player recoils vertically for
[SerializeField] private float recoilXSpeed = 100; //the speed of horizontal recoil
[SerializeField] private float recoilYSpeed = 100; //the speed of vertical recoil
private int stepsXRecoiled, stepsYRecoiled; //the no. of steps recoiled horizontally and verticall
[Space(5)]
[Header("Health Settings")]
public int health;
public int maxHealth;
[SerializeField] GameObject bloodSpurt;
[SerializeField] float hitFlashSpeed;
public delegate void OnHealthChangedDelegate();
[HideInInspector] public OnHealthChangedDelegate onHealthChangedCallback;
float healTimer;
[SerializeField] float timeToHeal;
[Space(5)]
[Header("Mana Settings")]
[SerializeField] UnityEngine.UI.Image manaStorage;
[SerializeField] float mana;
[SerializeField] float manaDrainSpeed;
[SerializeField] float manaGain;
[Space(5)]
[Header("Spell Settings")]
//spell stats
[SerializeField] float manaSpellCost = 0.3f;
[SerializeField] float timeBetweenCast = 0.5f;
float timeSinceCast;
[SerializeField] float spellDamage; //upspellexplosion and downspellfireball
[SerializeField] float downSpellForce; // desolate dive only
//spell cast objects
[SerializeField] GameObject sideSpellFireball;
[SerializeField] GameObject upSpellExplosion;
[SerializeField] GameObject downSpellFireball;
[Space(5)]
[HideInInspector] public PlayerStateList pState;
private Animator anim;
private Rigidbody2D rb;
private SpriteRenderer sr;
//Input Variables
private float xAxis, yAxis;
private bool attack = false;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
Health = maxHealth;
}
// Start is called before the first frame update
void Start()
{
pState = GetComponent<PlayerStateList>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
gravity = rb.gravityScale;
Mana = mana;
manaStorage.fillAmount = Mana;
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red;
Gizmos.DrawWireCube(SideAttackTransform.position, SideAttackArea);
Gizmos.DrawWireCube(UpAttackTransform.position, UpAttackArea);
Gizmos.DrawWireCube(DownAttackTransform.position, DownAttackArea);
}
// Update is called once per frame
void Update()
{
GetInputs();
UpdateJumpVariables();
if (pState.dashing) return;
RestoreTimeScale();
FlashWhileInvincible();
Move();
Heal();
CastSpell();
if (pState.healing) return;
Flip();
Jump();
StartDash();
Attack();
}
private void OnTriggerEnter2D(Collider2D _other) //for up and down cast spell
{
if(_other.GetComponent<Enemy>() != null && pState.casting)
{
_other.GetComponent<Enemy>().EnemyHit(spellDamage, (_other.transform.position - transform.position).normalized, -recoilYSpeed);
}
}
private void FixedUpdate()
{
if (pState.dashing || pState.healing) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(Mathf.Abs(transform.localScale.x), transform.localScale.y);
pState.lookingRight = true;
}
}
private void Move()
{
if (pState.healing) rb.velocity = new Vector2(0, 0);
rb.velocity = new Vector2(walkSpeed * xAxis, rb.velocity.y);
anim.SetBool("Walking", rb.velocity.x != 0 && Grounded());
}
void StartDash()
{
if (Input.GetButtonDown("Dash") && canDash && !dashed)
{
StartCoroutine(Dash());
dashed = true;
}
if (Grounded())
{
dashed = false;
}
}
IEnumerator Dash()
{
canDash = false;
pState.dashing = true;
anim.SetTrigger("Dashing");
rb.gravityScale = 0;
rb.velocity = new Vector2(transform.localScale.x * dashSpeed, 0);
if (Grounded()) Instantiate(dashEffect, transform);
yield return new WaitForSeconds(dashTime);
rb.gravityScale = gravity;
pState.dashing = false;
yield return new WaitForSeconds(dashCooldown);
canDash = true;
}
void Attack()
{
timeSinceAttack += Time.deltaTime;
if (attack && timeSinceAttack >= timeBetweenAttack)
{
timeSinceAttack = 0;
anim.SetTrigger("Attacking");
if (yAxis == 0 || yAxis < 0 && Grounded())
{
Hit(SideAttackTransform, SideAttackArea, ref pState.recoilingX, recoilXSpeed);
Instantiate(slashEffect, SideAttackTransform);
}
else if (yAxis > 0)
{
Hit(UpAttackTransform, UpAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, 80, UpAttackTransform);
}
else if (yAxis < 0 && !Grounded())
{
Hit(DownAttackTransform, DownAttackArea, ref pState.recoilingY, recoilYSpeed);
SlashEffectAtAngle(slashEffect, -90, DownAttackTransform);
}
}
}
void Hit(Transform _attackTransform, Vector2 _attackArea, ref bool _recoilDir, float _recoilStrength)
{
Collider2D[] objectsToHit = Physics2D.OverlapBoxAll(_attackTransform.position, _attackArea, 0, attackableLayer);
List<Enemy> hitEnemies = new List<Enemy>();
if(objectsToHit.Length > 0)
{
_recoilDir = true;
}
for(int i = 0; i < objectsToHit.Length; i++)
{
Enemy e = objectsToHit[i].GetComponent<Enemy>();
if(e && !hitEnemies.Contains(e))
{
e.EnemyHit(damage, (transform.position - objectsToHit[i].transform.position).normalized, _recoilStrength);
hitEnemies.Add(e);
if (objectsToHit[i].CompareTag("Enemy"))
{
Mana += manaGain;
}
}
}
}
void SlashEffectAtAngle(GameObject _slashEffect, int _effectAngle, Transform _attackTransform)
{
_slashEffect = Instantiate(_slashEffect, _attackTransform);
_slashEffect.transform.eulerAngles = new Vector3(0, 0, _effectAngle);
_slashEffect.transform.localScale = new Vector2(transform.localScale.x, transform.localScale.y);
}
void Recoil()
{
if (pState.recoilingX)
{
if (pState.lookingRight)
{
rb.velocity = new Vector2(-recoilXSpeed, 0);
}
else
{
rb.velocity = new Vector2(recoilXSpeed, 0);
}
}
if (pState.recoilingY)
{
rb.gravityScale = 0;
if (yAxis < 0)
{
rb.velocity = new Vector2(rb.velocity.x, recoilYSpeed);
}
else
{
rb.velocity = new Vector2(rb.velocity.x, -recoilYSpeed);
}
airJumpCounter = 0;
}
else
{
rb.gravityScale = gravity;
}
//stop recoil
if (pState.recoilingX && stepsXRecoiled < recoilXSteps)
{
stepsXRecoiled++;
}
else
{
StopRecoilX();
}
if (pState.recoilingY && stepsYRecoiled < recoilYSteps)
{
stepsYRecoiled++;
}
else
{
StopRecoilY();
}
if (Grounded())
{
StopRecoilY();
}
}
void StopRecoilX()
{
stepsXRecoiled = 0;
pState.recoilingX = false;
}
void StopRecoilY()
{
stepsYRecoiled = 0;
pState.recoilingY = false;
}
public void TakeDamage(float _damage)
{
Health -= Mathf.RoundToInt(_damage);
StartCoroutine(StopTakingDamage());
}
IEnumerator StopTakingDamage()
{
pState.invincible = true;
GameObject _bloodSpurtParticles = Instantiate(bloodSpurt, transform.position, Quaternion.identity);
Destroy(_bloodSpurtParticles, 1.5f);
anim.SetTrigger("TakeDamage");
yield return new WaitForSeconds(1f);
pState.invincible = false;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
}
void RestoreTimeScale()
{
if (restoreTime)
{
if (Time.timeScale < 1)
{
Time.timeScale += Time.unscaledDeltaTime * restoreTimeSpeed;
}
else
{
Time.timeScale = 1;
restoreTime = false;
}
}
}
public void HitStopTime(float _newTimeScale, int _restoreSpeed, float _delay)
{
restoreTimeSpeed = _restoreSpeed;
if (_delay > 0)
{
StopCoroutine(StartTimeAgain(_delay));
StartCoroutine(StartTimeAgain(_delay));
}
else
{
restoreTime = true;
}
Time.timeScale = _newTimeScale;
}
IEnumerator StartTimeAgain(float _delay)
{
yield return new WaitForSecondsRealtime(_delay);
restoreTime = true;
}
public int Health
{
get { return health; }
set
{
if (health != value)
{
health = Mathf.Clamp(value, 0, maxHealth);
if (onHealthChangedCallback != null)
{
onHealthChangedCallback.Invoke();
}
}
}
}
void Heal()
{
if (Input.GetButton("Healing") && Health < maxHealth && Mana > 0 && Grounded() && !pState.dashing)
{
pState.healing = true;
anim.SetBool("Healing", true);
//healing
healTimer += Time.deltaTime;
if (healTimer >= timeToHeal)
{
Health++;
healTimer = 0;
}
//drain mana
Mana -= Time.deltaTime * manaDrainSpeed;
}
else
{
pState.healing = false;
anim.SetBool("Healing", false);
healTimer = 0;
}
}
float Mana
{
get { return mana; }
set
{
//if mana stats change
if (mana != value)
{
mana = Mathf.Clamp(value, 0, 1);
manaStorage.fillAmount = Mana;
}
}
}
void CastSpell()
{
if (Input.GetButtonDown("CastSpell") && timeSinceCast >= timeBetweenCast && Mana >= manaSpellCost)
{
pState.casting = true;
timeSinceCast = 0;
StartCoroutine(CastCoroutine());
}
else
{
timeSinceCast += Time.deltaTime;
}
if(Grounded())
{
//disable downspell if on the ground
downSpellFireball.SetActive(false);
}
//if down spell is active, force player down until grounded
if(downSpellFireball.activeInHierarchy)
{
rb.velocity += downSpellForce * Vector2.down;
}
}
IEnumerator CastCoroutine()
{
anim.SetBool("Casting", true);
yield return new WaitForSeconds(0.15f);
//side cast
if (yAxis == 0 || (yAxis < 0 && Grounded()))
{
GameObject _fireBall = Instantiate(sideSpellFireball, SideAttackTransform.position, Quaternion.identity);
//flip fireball
if(pState.lookingRight)
{
_fireBall.transform.eulerAngles = Vector3.zero; // if facing right, fireball continues as per normal
}
else
{
_fireBall.transform.eulerAngles = new Vector2(_fireBall.transform.eulerAngles.x, 180);
//if not facing right, rotate the fireball 180 deg
}
pState.recoilingX = true;
}
//up cast
else if( yAxis > 0)
{
Instantiate(upSpellExplosion, transform);
rb.velocity = Vector2.zero;
}
//down cast
else if(yAxis < 0 && !Grounded())
{
downSpellFireball.SetActive(true);
}
Mana -= manaSpellCost;
yield return new WaitForSeconds(0.35f);
anim.SetBool("Casting", false);
pState.casting = false;
}
public bool Grounded()
{
if (Physics2D.Raycast(groundCheckPoint.position, Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround)
|| Physics2D.Raycast(groundCheckPoint.position + new Vector3(-groundCheckX, 0, 0), Vector2.down, groundCheckY, whatIsGround))
{
return true;
}
else
{
return false;
}
}
void Jump()
{
if (!pState.jumping)
{
if (jumpBufferCounter > 0 && coyoteTimeCounter > 0)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
else if(!Grounded() && airJumpCounter < maxAirJumps && Input.GetButtonDown("Jump"))
{
pState.jumping = true;
airJumpCounter++;
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
}
}
if (Input.GetButtonUp("Jump") && rb.velocity.y > 0)
{
rb.velocity = new Vector2(rb.velocity.x, 0);
pState.jumping = false;
}
anim.SetBool("Jumping", !Grounded());
}
void UpdateJumpVariables()
{
if (Grounded())
{
pState.jumping = false;
coyoteTimeCounter = coyoteTime;
airJumpCounter = 0;
}
else
{
coyoteTimeCounter -= Time.deltaTime;
}
if (Input.GetButtonDown("Jump"))
{
jumpBufferCounter = jumpBufferFrames;
}
else
{
jumpBufferCounter = jumpBufferCounter - Time.deltaTime * 10;
}
}
}
PlayerStateList.cs
public class PlayerStateList : MonoBehaviour
{
public bool jumping = false;
public bool dashing = false;
public bool recoilingX, recoilingY;
public bool lookingRight;
public bool invincible;
public bool healing;
public bool casting;
}
HeartController.cs
using UnityEngine.UI;
public class HeartController : MonoBehaviour
{
private GameObject[] heartContainers;
private Image[] heartFills;
public Transform heartsParent;
public GameObject heartContainerPrefab;
// Start is called before the first frame update
void Start()
{
heartContainers = new GameObject[PlayerController.Instance.maxHealth];
heartFills = new Image[PlayerController.Instance.maxHealth];
PlayerController.Instance.onHealthChangedCallback += UpdateHeartsHUD;
InstantiateHeartContainers();
UpdateHeartsHUD();
}
// Update is called once per frame
void Update()
{
}
void SetHeartContainers()
{
for(int i = 0; i < heartContainers.Length; i++)
{
if(i < PlayerController.Instance.maxHealth)
{
heartContainers[i].SetActive(true);
}
else
{
heartContainers[i].SetActive(false);
}
}
}
void SetFilledHearts()
{
for (int i = 0; i < heartFills.Length; i++)
{
if (i < PlayerController.Instance.Health)
{
heartFills[i].fillAmount = 1;
}
else
{
heartFills[i].fillAmount = 0;
}
}
}
void InstantiateHeartContainers()
{
for(int i = 0; i < PlayerController.Instance.maxHealth; i++)
{
GameObject temp = Instantiate(heartContainerPrefab);
temp.transform.SetParent(heartsParent, false);
heartContainers[i] = temp;
heartFills[i] = temp.transform.Find("HeartFill").GetComponent<Image>();
}
}
void UpdateHeartsHUD()
{
SetHeartContainers();
SetFilledHearts();
}
}
Fireball.cs
public class FireBall : MonoBehaviour
{
[SerializeField] float damage;
[SerializeField] float hitForce;
[SerializeField] int speed;
[SerializeField] float lifetime = 1;
// Start is called before the first frame update
void Start()
{
Destroy(gameObject, lifetime);
}
private void FixedUpdate()
{
transform.position += speed * transform.right;
}
//detect hit
private void OnTriggerEnter2D(Collider2D _other)
{
if(_other.tag == "Enemy")
{
_other.GetComponent<Enemy>().EnemyHit(damage, (_other.transform.position - transform.position).normalized, -hitForce);
}
}
}
Enemy.cs
public class Enemy : MonoBehaviour
{
[SerializeField] protected float health;
[SerializeField] protected float recoilLength;
[SerializeField] protected float recoilFactor;
[SerializeField] protected bool isRecoiling = false;
[SerializeField] protected float speed;
[SerializeField] protected float damage;
protected float recoilTimer;
protected Rigidbody2D rb;
// Start is called before the first frame update
protected virtual void Start()
{
rb = GetComponent<Rigidbody2D>();
}
// Update is called once per frame
protected virtual void Update()
{
if(health <= 0)
{
Destroy(gameObject);
}
if(isRecoiling)
{
if(recoilTimer < recoilLength)
{
recoilTimer += Time.deltaTime;
}
else
{
isRecoiling = false;
recoilTimer = 0;
}
}
}
public virtual void EnemyHit(float _damageDone, Vector2 _hitDirection, float _hitForce)
{
health -= _damageDone;
if(!isRecoiling)
{
rb.AddForce(-_hitForce * recoilFactor * _hitDirection);
isRecoiling = True;
}
}
protected void OnCollisionStay2D(Collision2D _other)
{
if(_other.gameObject.CompareTag("Player") && !PlayerController.Instance.pState.invincible)
{
Attack();
PlayerController.Instance.HitStopTime(0, 5, 0.5f);
}
}
protected virtual void Attack()
{
PlayerController.Instance.TakeDamage(damage);
}
}