Welcome to Part 5 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!
- Introduction
- Bug Fixes and Improvements
- Level Design
- Scene Transitions
- Creating Lighting for our Cave Scenes
1. Introduction
Welcome back to our Metroidvania tutorial series! In this fifth instalment, we will enhance the mechanics we have already established and introduce some exciting new features. Get ready to level up your game development skills as we delve into the art of crafting intricate levels reminiscent of those in Hollow Knight. We will explore how to create a parallax effect with multiple layers, as well as implement scene transitions for seamless navigation between different areas. Now without further ado, let’s start off with some improvements for our Metroidvania game.
2. Bug Fixes and Improvements
In this section, we’ll be making a few adjustments to the project so that our game performs more smoothly and reliably for the player while also fixing some minor bugs along the way.
a. Changing spell sprites’ filter mode
We’ll first change the filter mode of the sprites we use for our spells from Point (no filter) to Bilinear to avoid our spells looking pixelated.
Let’s then convert the Player and the Canvas into a prefab so that we can use these assets in other scenes without having to constantly duplicate them.
b. Binding Casting and Healing to the same button
Next, let’s streamline the casting and healing actions by assigning them to the same button:
- Open the Input Manager and rename the Healing button to Cast/Heal to reflect its new dual functionality.
- In the
PlayerControllerscript, create a timer variable calledcastOrHealTimerto track how long the spell/heal button has been pressed. - In the
GetInputs()method, if the Cast/Heal is held down then we addTime.deltaTimeto thecastOrHealTimer. Else we reset the timer. - Modify the spell-casting condition to use
Input.GetButtonUpand check if the timer is less than or equal to 0.05f. - Adjust the healing condition to use
Input.GetButton()and check if the timer is greater than 0.05f.
PlayerController.cs
using UnityEngine.UIElements;
using UnityEngine.UI;
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 int jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private int 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;
float castOrHealTimer;
[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");
if (Input.GetButton("Cast/Heal"))
{
castOrHealTimer += Time.deltaTime;
}
else
{
castOrHealTimer = 0;
}
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-1, transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(1, 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)
{
restoreTime = true;
yield return new WaitForSecondsRealtime(_delay);
}
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") Input.GetButton("Cast/Heal") && castOrHealTimer > 0.05f && 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") Input.GetButtonUp("Cast/Heal") && castOrHealTimer <= 0.05f && 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--;
}
}
}
Implementing these changes simplifies the gameplay mechanics, allowing players to seamlessly cast spells or heal with a single button press.
Change the if parameter of both Heal() and CastSpell() to a higher float value if needed as 0.05f is a very limited time for a player to tap and fire a spell.
You should also change the Input Manager’s unused Inputs to another input to make full use of it.
c. Fixing Bugs and Improving the Player’s Jump
To prevent Grounded() from being set to true when the player hits the side of a ground platform, change the Player’s Ground Check X value to 0.4. This prevents the player from gaining their air jumps and dash back when hitting the side of Ground layer game objects.
Let’s also improve the reliablility of the Jump() method:
- Remove the jump code from the
!pState.jumpingif statement and only add!pState.jumpingto the ground jump code. - Remove the else from the air jump code.
- Refine the Jump() method by replacing the condition
Input.GetButtonUp("Jump")andrb.velocity > 0withrb.velocity > 3.
PlayerController.cs
using UnityEngine.UIElements;
using UnityEngine.UI;
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 int jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private int 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;
float castOrHealTimer;
[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");
if (Input.GetButton("Cast/Heal"))
{
castOrHealTimer += Time.deltaTime;
}
else
{
castOrHealTimer = 0;
}
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-1, transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(1, 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)
{
restoreTime = true;
yield return new WaitForSecondsRealtime(_delay);
}
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("Cast/Heal") && castOrHealTimer > 0.05f && 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.GetButtonUp("Cast/Heal") && castOrHealTimer <= 0.05f && 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 (!pState.jumping && 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 > 3)
{
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--;
}
}
}
Let’s make adjustments to the blood spurt particle system:
- Set the Start Size to 0.1 to 0.7.
- Reshape the size over the lifetime curve to decrease particles over time.
- Set the velocity over lifetime to a linear curve.
- Set the x to a decreasing curve
- Set y curves to the increase.
- Adjust the gravity modifier from -0.7 to -7.
- Set the speed modifier curve to increase exponentially.
- Set Delta Time to Unscaled.
d. Set the Dash Direction to be based on Player State
Next, let’s set our dash direction to be based on pState.lookingRight instead of based on localScale to give our code more flexibilty in the event that we need to change our Flip() method to somthing other than through the player’s scale.
PlayerController.cs
using UnityEngine.UIElements;
using UnityEngine.UI;
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 int jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private int 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;
float castOrHealTimer;
[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");
if (Input.GetButton("Cast/Heal"))
{
castOrHealTimer += Time.deltaTime;
}
else
{
castOrHealTimer = 0;
}
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-1, transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(1, 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;
int _dir = pState.lookingRight ? 1 : -1;
rb.velocity = new Vector2(transform.localScale.x _dir * 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)
{
restoreTime = true;
yield return new WaitForSecondsRealtime(_delay);
}
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("Cast/Heal") && castOrHealTimer > 0.05f && 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.GetButtonUp("Cast/Heal") && castOrHealTimer <= 0.05f && 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 (jumpBufferCounter > 0 && coyoteTimeCounter > 0 && !pState.jumping)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
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 > 3)
{
pState.jumping = false;
rb.velocity = new Vector2(rb.velocity.x, 0);
}
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--;
}
}
}
e. Rework Singleton to Carry Over to the Next Scene
Currently, our singleton doesn’t carry over to the next scene and only creates a static refrence to our player. We’ll want to make our Singleton Instance not be destroyed when changing scenes while also destroying any copies that may appear.
You can do this by adding DontDestroyOnLoad(gameObject) to the bottom of the Awake() function. We’ll also be moving our Health = maxHealth from the Awake() function to the Start() function.
PlayerController.cs
using UnityEngine.UIElements;
using UnityEngine.UI;
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 int jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private int 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;
float castOrHealTimer;
[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;
}
DontDestroyOnLoad(gameObject);
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;
Health = maxHealth;
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");
if (Input.GetButton("Cast/Heal"))
{
castOrHealTimer += Time.deltaTime;
}
else
{
castOrHealTimer = 0;
}
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-1, transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(1, 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;
int _dir = pState.lookingRight ? 1 : -1;
rb.velocity = new Vector2(_dir * 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)
{
restoreTime = true;
yield return new WaitForSecondsRealtime(_delay);
}
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("Cast/Heal") && castOrHealTimer > 0.05f && 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.GetButtonUp("Cast/Heal") && castOrHealTimer <= 0.05f && 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 (jumpBufferCounter > 0 && coyoteTimeCounter > 0 && !pState.jumping)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
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 > 3)
{
pState.jumping = false;
rb.velocity = new Vector2(rb.velocity.x, 0);
}
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--;
}
}
}
Make sure that there is only one scene containing your Prefabs with singleton scripts such as the Player and Canvas. Entering a scene with a second singleton instance will cause NullReferenceException errors as scripts cannot differentiate or single out one script instance from multiple.
3. Level Design
And with those improvements in place, we’re ready to dive into the heart of this part. In this section, we’ll explore the fascinating world of parallax and learn how to create stunning scenes with multiple layers, just like the enchanting environments found in Hollow Knight.
Now, before we dive into this section, I want to emphasize that level design is a creative process that allows for your own input and ideas. While I’ll be demonstrating specific techniques and concepts, it’s essential to understand that flexibility and personalization are key. So, let’s focus on learning the concepts and tricks I’ll be sharing rather than strictly following this part of the tutorial.
Parallax is a technique used in game development to add depth and visual interest to 2D environments. It involves layering multiple images or elements at different distances from the camera, creating an illusion of depth and movement as the player navigates through the scene.
a. Setting up the Assets and Scene
I’ll be using the 2D DarkCave Assets pack from itch.io to build my scenes with.
Let’s get started with the following steps:
- Rename the current scene to Cave_1 for better organization and clarity.
- Adjust the sprite settings in your asset pack:
- Set the pixels per unity to 32.
- Change all sprites to Multiple mode.
- Increase the maximum size to 4096.
- Select None for compression. This ensures optimal quality and performance.
- Utilize the automatic slice feature to cut up the sprite sheets into individual usable sprites. This simplifies working with sprites in your scene.
- Create three sorting layers in the Sprite Renderer:
- Background
- Midground
- Foreground
- Make sure they are in the correct order. This allows for better organization and control of the visual stacking order of game objects.
- Change your Main Camera’s Camera component’s Projection from Orthographic to Perspective.
- Set up game objects for the parallax layers:
- Create three new game objects: Background, Midground, and Foreground.
- Create child game objects within each of the three parent game objects:
- Name them based on their parent game object’s name, adding “_0,” “_1,” and “_2” at the end.
- For example: Background_0, Background_1, and Background_2.
- Adjust the Z-Position of the child game objects layers to create the desired depth effect:
- Background_0: 5
- Background_1: 10
- Background_2: 15
- Midground_0: 0.5
- Midground_1: 0
- Midground_2: -0.5
- Foreground_0: -2
- Foreground_1: -4
- Foreground_2: -6
These distinct layers will serve as our canvas for building a rich sense of depth, similar to what we find in Hollow Knight.
b. Building the Level
Unleash your creativity and construct a captivating parallax scene in Unity with these simple steps:
i. The Midground
- Use the Floor 8 sprite as the base for your floor. Attach these sprites to the Midground_1 game object.
- Set their sorting layer to Midground and order in layer to 0.
- Set their layer to Ground and add a Box Collider 2D that fits within the sprite.
- Duplicate these sprites to create the entire length of the floor.
- Optional: Add variation by using the Floor 9 sprites.
- Improve the appearance of the floor tiles by addressing the gaps between them.
- Go to the camera and change the background type to Solid Color instead of Skybox.
- Set the background colour to black for a cohesive look.
- Add rocks and stalagmites to fill in the gaps and enhance the scene’s detail.
- Place these elements in front of the gaps between the floor tiles.
- Attach them to the Midground_2 object.
- Duplicate them to add more visual interest.
- Adjust the sorting layer of these elements as needed.
- Hit the play button, and you’ll witness a seamless cave floor in action.
Next, we’ll create the walls and ceilings for our cave scene.
For Creating Walls:
- Use long vertical floor sprites to form the walls around the scene.
- Fill the gaps in the walls with shorter vertical floor tiles.
- Set the sorting layer of the gap fillers to Midground and order to -1 for proper visual placement.
- Set the main wall tiles’ sorting layer to Midground and order to 0 to ensure they appear correctly.
For Designing Ceilings:
- Utilize floor tiles that face down to create the ceiling.
- Follow the same process as with the walls to ensure consistency in sorting layers and visual alignment.
ii. The Foreground
In addition to our focus on walls and ceilings, we mustn’t overlook the importance of the foreground. By incorporating rocks, stalagmites, and stalactites into the foreground layers, we can create a more immersive environment. To ensure proper visual positioning, it’s essential to adjust the sorting layers of rocks, stalagmites, and stalactites in the foreground. When these elements are in the layer above, they should appear in front of other objects. Conversely, when they are in the layer behind, they should appear behind other objects. This approach guarantees a seamless and realistic visual experience for the players.
To further enhance the depth of field effect and maintain player immersion, I recommend darkening the colour of these foreground elements making the foreground element darker the closer it is to the camera. This technique helps to prevent distractions while maintaining their role in the overall aesthetic. By carefully considering the visual impact of these foreground features, we can craft a more captivating and engaging game world.
iii. The Background
In the next step, let’s focus on the background. Follow these steps to create a visually appealing rock column:
- Utilize the vertical floor sprites to construct a large rock column. These sprites will form the main structure.
- Use the same sprites to create the sides of the column, ensuring a seamless and cohesive design.
- In the center of the column, place the black square provided in the sprite pack. This will add a contrasting element.
- To keep things organized, create a parent object named Collumn and attach it to the Background_2.
- Set the sprites to the background sorting layer, ensuring they blend seamlessly with the background.
- Make sure to reset the z position of the column and its sprites to match the Background_2 layer, maintaining proper layering and depth.
To create a convincing depth of field effect in the background, we’ll incorporate fog into each layer. This technique involves blurring the background elements progressively as they recede into the distance. By implementing fog, we enhance the illusion of depth, giving the impression that these background layers are situated farther away than their actual position suggests.
In order to achieve a blurred effects:
- Create a child square sprite for each background layer and resize them to cover the entire scene.
- Set the alpha value of these squares to 77 for a slightly transparent appearance.
- Adjust the sorting layer of the squares to Background and ensure that their order number is higher than the background layer.
- This setup will create a foggy and blurry background as you move deeper into the scene.
iv. Adding Detail to our Environment
To introduce platforms and enhance the level design, proceed as follows:
- Select platform sprites from the platform sprites sheet.
- Add a Box Collider 2D to each platform sprite and adjust it to fit the shape of the sprite.
- Set the collider type to Ground to enable player interaction and movement on these platforms.
The asset pack includes animated plants that add foliage to our scene. To incorporate them effectively, follow these steps:
- Adjust Vegetation settings:
- Set pixels per unit to 32.
- Change all sprites to Multiple mode.
- Increase the maximum size of sprites to 4096.
- Select None for compression.
- Create game objects for each vegetation type:
- Use the sprites provided for each plant.
- Create animations for these objects, sequencing the sprites accordingly.
- Save the animations in the designated animation folder.
- Ensure that the animations are set to loop.
- Make the plants into prefabs:
- Create a Plants folder in the prefabs directory.
- Save each plant as a prefab in this folder.
- Enhance the level with vegetation:
- Place the prefab plants throughout the scene, considering different layers for added depth.
- Apply the concepts discussed earlier, such as darkening foreground elements, to achieve a realistic depth-of-field effect.
Let’s then also change the sorting layer of our prefabs, such as the Player and Blood Spurt, to Midground order 1. This will be the specific layer and order that almost all gameplay will take place on.
c. Adding Other Levels
In our next step, we’ll create two additional scenes: Cave_2 and Cave_3. Here’s what each scene will involve:
- Cave_2: This scene will be a long horizontal room filled with challenging platforming obstacles. At the end of the room, we’ll include a shortcut that allows the player to return to the starting point quickly.
- Cave_3: This scene will have an upside-down capital T shape and feature a vertical platforming section. The vertical section will lead to two rooms located at the bottom.
Remember to include the player and the canvas in these scenes as well. The process and concepts used in creating Cave_1 will be applied here too.
Go to File -> Build Settings then open each scene (Cave_2 and Cave_3) and click Add Open Scenes in the Build Window. By adding the scenes to the build, we ensure that they will function properly for our next exciting feature: scene transitions!
4. Scene Transitions
Scene transitions are an essential aspect of game development, allowing players to seamlessly move between different areas and levels. In this article, we will explore how to create scene transitions with multiple entrances and exits, providing players with a rich and immersive gaming experience. By following the steps outlined in this tutorial, you will learn how to implement triggers, define entry points, and manage transitions between scenes. Get ready to take your game to the next level by mastering the art of smooth and dynamic scene transitions. Let’s dive in!
a. Creating the Scene Transition
Let’s first set up the Scene Transition game object and script:
- Create a game object called Scene Transition with a Box Collider 2D and set its Is Trigger to true.
- Add a child empty game object called start point to define the player’s entry point in the scene.
- Create the
SceneTransitionscript on the game object and include the following serializable private variables:stringtransitionTo: Represents the scene to transition to.TransformstartPoint: Defines the player’s entry point in the scene.Vector2exitDirection: Specifies the direction for the player’s exit.floatexitTime: Determines the time it takes for the player to exit the scene transition.
To handle the scene transition:
- In the O
nTriggerEnter2Dfunction, check if the entering object is the player. - Declare that we’ll be using the
UnityEngine.SceneManagementlibrary. - If the entering object is the player, load the next scene using
SceneManagement.LoadScene(transitionTo).
To ensure the player starts at the designated entry point when entering a scene:
- Create a Game Manager object and attach a
GameManagerscript to it. - Make the
GameManagera singleton, similar to the one in ourPlayerControllerscript. - Add a
publicstringvariable calledtransitionedFromSceneto store the previous scene. - In the
Start()function of theSceneTransitionscript, check if thetransitionTovariable matches thetransitionedFromScenevariable. - If they match, set the Player instance’s position to the
startPointposition. - Before loading the new scene, set the
transitionedFromScenevariable to the active scene when the player enters the trigger.
SceneTransition.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
public class SceneTransition : MonoBehaviour
{
[SerializeField] private string transitionTo; //Represents the scene to transition to
[SerializeField] private Transform startPoint; //Defines the player's entry point in the scene
[SerializeField] private Vector2 exitDirection; //Specifies the direction for the player's exit
[SerializeField] private float exitTime; //Determines the time it takes for the player to exit the scene transition
// Start is called before the first frame update
private void Start()
{
if(GameManager.Instance.transitionedFromScene == transitionTo)
{
PlayerController.Instance.transform.position = startPoint.position;
}
}
private void Update()
{
}
private void OnTriggerEnter2D(Collider2D _other)
{
if (_other.CompareTag("Player"))
{
GameManager.Instance.transitionedFromScene = SceneManager.GetActiveScene().name;
SceneManager.LoadScene(transitionTo);
}
}
}
GameManager.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class GameManager : MonoBehaviour
{
public string transitionedFromScene;
public static GameManager Instance { get; private set; }
private void Awake()
{
if(Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
DontDestroyOnLoad(gameObject);
}
// Start is called before the first frame update
void Start()
{
}
// Update is called once per frame
void Update()
{
}
}
Let’s return to Cave_1 and add a hole on the left wall to enable our scene transition. Afterwards, we’ll proceed to assign the necessary variables. Set the transition to to Cave_2 and specify the exit direction as 1, considering that the player moves towards the right upon exiting the scene transition. Additionally, set the exit time to 0.25 for later use.
Upon testing the scene, we should observe a seamless transition from one scene to the next. To enhance this feature, we can convert it into a prefab for convenience and reusability since we’re gonna be needing one in almost every scene we make.
b. Create a Mini Cutscene for the Scene Transition
Let’s further improve the scene transition by making a mini cutscene for the entering and exiting of scene transitions.
Go back to the PlayerController script, add a public coroutine called WalkIntoNewScene(), and pass two arguments, a Vector2 _exitDir, and a float _delay. Then add a new public bool to our PlayerStateList called cutscene and set its default to false. With the new cutscene bool, set an if statement to return in the PlayerController script’s Update() and FixedUpdate() if the bool is true. In the WalkIntoNewScene() coroutine add these steps:
- Initial Condition: The method begins by evaluating a specific condition, which checks if the vertical component of a directional vector exceeds zero.
- This criterion is crucial when the player needs to execute a vertical jump as part of the scene transition.
- Vertical Jump: Once the condition is satisfied, the player’s movement is affected by adjusting the velocity of their associated Rigidbody2D.
- This alteration ensures the player performs a vertical jump with an appropriate force and direction.
- Horizontal Movement: The subsequent step revolves around assessing whether the horizontal component of the aforementioned directional vector differs from zero.
- This evaluation facilitates the management of the player’s horizontal movement during the scene transition.
- Determining Direction: Within the context of horizontal movement, a variable is assigned a specific value based on the horizontal component of the directional vector.
- This assigned value dictates the direction in which the player should move.
- Player Movement: Following the direction determination, the player’s movement is effectively handled by invoking a dedicated function responsible for controlling their motion.
- Orientation Adjustment: To ensure proper visual alignment, an additional function is called to handle any necessary flipping or rotation of the player’s sprite or game object.
- This guarantees that the player consistently faces the intended direction during the cutscene.
- Transitional Pause: After executing the prescribed actions, the program pauses for a designated duration to allow the transitional animation to play out.
- Preventing Enemy Interruption: While within the cutscene, set the player’s
invinciblestate totrueto stop any unintentional lost of health or time stops. - Cutscene Conclusion: As the transitional effects draw to a close, a specific variable associated with the player’s state and
invinciblestate is reset to indicate the termination of the cutscene or transition sequence. This signifies that the player has regained control over their movements.
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;
public bool cutscene = false;
}
PlayerController.cs
using UnityEngine.UIElements;
using UnityEngine.UI;
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 int jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private int 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;
float castOrHealTimer;
[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;
}
DontDestroyOnLoad(gameObject);
}
// 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;
Health = maxHealth;
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()
{
if (pState.cutscene) return;
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 || pState.cutscene) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
if (Input.GetButton("Cast/Heal"))
{
castOrHealTimer += Time.deltaTime;
}
else
{
castOrHealTimer = 0;
}
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-1, transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(1, 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;
int _dir = pState.lookingRight ? 1 : -1;
rb.velocity = new Vector2(_dir * 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;
}
public IEnumerator WalkIntoNewScene(Vector2 _exitDir, float _delay)
{
pstate.invincible = true;
//If exit direction is upwards
if(_exitDir.y > 0)
{
rb.velocity = jumpForce * _exitDir;
}
//If exit direction requires horizontal movement
if(_exitDir.x != 0)
{
xAxis = _exitDir.x > 0 ? 1 : -1;
Move();
}
Flip();
yield return new WaitForSeconds(_delay);
pstate.invincible = false;
pState.cutscene = false;
}
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)
{
restoreTime = true;
yield return new WaitForSecondsRealtime(_delay);
}
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("Cast/Heal") && castOrHealTimer > 0.05f && 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.GetButtonUp("Cast/Heal") && castOrHealTimer <= 0.05f && 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 (jumpBufferCounter > 0 && coyoteTimeCounter > 0 && !pState.jumping)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
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 > 3)
{
pState.jumping = false;
rb.velocity = new Vector2(rb.velocity.x, 0);
}
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--;
}
}
}
We’ll then call the coroutine in our SceneTransition script in the start function under the startPoint line of code in the if statement. We’ll also set the player’s cutscene and invincible bool to true before loading a new scene.
SceneTransition.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
public class SceneTransition : MonoBehaviour
{
[SerializeField] private string transitionTo; //Represents the scene to transition to
[SerializeField] private Transform startPoint; //Defines the player's entry point in the scene
[SerializeField] private Vector2 exitDirection; //Specifies the direction for the player's exit
[SerializeField] private float exitTime; //Determines the time it takes for the player to exit the scene transition
// Start is called before the first frame update
private void Start()
{
if(GameManager.Instance.transitionedFromScene == transitionTo)
{
PlayerController.Instance.transform.position = startPoint.position;
StartCoroutine(PlayerController.Instance.WalkIntoNewScene(exitDirection, exitTime));
}
}
private void OnTriggerEnter2D(Collider2D _other)
{
if (_other.CompareTag("Player"))
{
GameManager.Instance.transitionedFromScene = SceneManager.GetActiveScene().name;
PlayerController.Instance.pState.cutscene = true;
PlayerController.Instance.pState.invincible = true;
SceneManager.LoadScene(transitionTo);
}
}
}
Let’s go back to Cave_2 and add a scene transition on the right wall. We’ll set the x to -1 for our exit direction as we want to exit straight towards the left. Set the transition to variable to Cave_1. And now if we try out the scene transition we should have a nice walking cutscene as the player walks out of the scene transition.
We can also have a vertical scene transition. Let’s create a hole and a scene transition to Cave_3. We’ll then set the exit direction to (-1, 1).
This is so that the player will jump out of the scene transition at a diagonal and jump up and out of the hole. Let’s also set the exit time as 0.5 so our player has enough time to jump out of the scene transition hole. Let’s then add a scene transition in Cave_3 back to Cave_1. We can leave the variables as 0 here since the player is simply falling out of the scene transition so no cutscene is required.
And now if we test the scene transition out we should have a smooth scene transition with the player jumping out.
I also like to rename the scene transitions according to what scene they’re transitioning to just to make it easier to keep track of. For example, I’ll rename the scene transition to Cave_2 to Cave_2 Transition.
c. Fading in and out of Scenes
Next, let’s add a fade to black as we transition between scenes and a fade out when we enter a scene. Let’s start by creating a script called UIManager in our canvas and making it a singleton.
UIManager.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class UIManager : MonoBehaviour
{
public static UIManager Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
DontDestroyOnLoad(gameObject);
}
private void Start()
{
}
private void Update()
{
}
}
To achieve the desired effect, follow these steps:
- Create a new game object as a child of the canvas and add an Image component to it.
- Set the Transform Position of the new game object to the bottom of the canvas to ensure it is rendered on top of other elements.
- Change the color of the Image component to black.
- Adjust the Image component’s properties to make it stretch and fill the canvas.
- Rename the new game object to “Scene Fader” and attach a script called
SceneFaderto it.
In the “SceneFader” script:
- Import the
UnityEngine.UIlibrary for accessing UI-related functionalities. - Declare a private and serializable float variable named
fadeTimeto control the duration of the fading effect. - Create a private variable of type
ImagenamedfadeOutUIImageand assign it the reference to the image component of the “Scene Fader” game object in theAwake()function using the code snippet below:
SceneFader.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class SceneFader : MonoBehaviour
{
[SerializeField] private float fadeTime;
private Image fadeOutUIImage;
private void Awake()
{
fadeOutUIImage = GetComponent<Image>();
}
private void Start()
{
}
private void Update()
{
}
}
Now, let’s work on the enum and a private method:
- Declare a public enum called
FadeDirectionto represent the options for fading in or fading out. - Implement a private method called
SetColorImage(ref float _alpha, FadeDirection _fadeDirection) - The
SetColorImage()method is responsible for setting the colour and transparency of the image component based on the provided_alphavalue. It takes two parameters:_alpha(a reference to a float) and_fadeDirection(a value from theFadeDirectionenum).- The method updates the colour of the image component, ensuring that the red, green, and blue values remain unchanged while modifying the alpha (transparency) value with the provided
_alphavalue. - Additionally, the method adjusts the
_alphavalue over time by using a formula that incorporatesTime.deltaTime. This ensures a consistent speed of adjustment regardless of the frame rate. The adjustment of_alphadepends on the specified_fadeDirection. If_fadeDirectionis set to “Out,” the_alphavalue is decreased, while if it is set to “In,” the_alphavalue is increased.
- The method updates the colour of the image component, ensuring that the red, green, and blue values remain unchanged while modifying the alpha (transparency) value with the provided
SceneFader.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class SceneFader : MonoBehaviour
{
[SerializeField] private float fadeTime;
private Image fadeOutUIImage;
public enum FadeDirection
{
In,
Out
}
private void Awake()
{
fadeOutUIImage = GetComponent<Image>();
}
void SetColorImage(ref float _alpha, FadeDirection _fadeDirection)
{
fadeOutUIImage.color = new Color(fadeOutUIImage.color.r, fadeOutUIImage.color.g, fadeOutUIImage.color.b, _alpha);
_alpha += Time.deltaTime * (1 / fadeTime) * (_fadeDirection == FadeDirection.Out ? -1 : 1);
}
}
Now, let’s create a public IEnumerator called Fade() and pass a FadeDirection argument called _fadeDirection into it.
Inside the Fade() function, add the following steps:
- Declare two local variables,
_alphaand_fadeEndValue. - Using a ternary conditional operator, set
_alphato 1 and_fadeEndValueto 0 if_fadeDirection == FadeDirection.Out; otherwise, set_alphato 0 and_fadeEndValueto 1.
Next, perform the following steps based on the _fadeDirection value:
- If
_fadeDirection == FadeDirection.Out:- Enter a loop while
_alphais greater than or equal to_fadeEndValue. - Call the
SetColorImage()method with_alphaand_fadeDirectionas arguments. yield return nullto wait for the next frame.- Disable the
fadeOutUIImagecomponent.
- Enter a loop while
- If
_fadeDirection == FadeDirection.In:- Enable the
fadeOutUIImagecomponent. - Enter a loop while
_alphais less than or equal to_fadeEndValue. - Call the
SetColorImage()method with_alphaand_fadeDirectionas arguments. yield return nullto wait for the next frame.
- Enable the
SceneFader.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class SceneFader : MonoBehaviour
{
[SerializeField] private float fadeTime;
private Image fadeOutUIImage;
public enum FadeDirection
{
In,
Out
}
private void Awake()
{
fadeOutUIImage = GetComponent<Image>();
}
public IEnumerator Fade(FadeDirection _fadeDirection)
{
float _alpha = _fadeDirection == FadeDirection.Out ? 1 : 0;
float _fadeEndValue = _fadeDirection == FadeDirection.Out ? 0 : 1;
if(_fadeDirection == FadeDirection.Out)
{
while(_alpha >= _fadeEndValue)
{
SetColorImage(ref _alpha, _fadeDirection);
yield return null;
}
fadeOutUIImage.enabled = false;
}
else
{
fadeOutUIImage.enabled = true;
while (_alpha <= _fadeEndValue)
{
SetColorImage(ref _alpha, _fadeDirection);
yield return null;
}
}
}
void SetColorImage(ref float _alpha, FadeDirection _fadeDirection)
{
fadeOutUIImage.color = new Color(fadeOutUIImage.color.r, fadeOutUIImage.color.g, fadeOutUIImage.color.b, _alpha);
_alpha += Time.deltaTime * (1 / fadeTime) * (_fadeDirection == FadeDirection.Out ? -1 : 1);
}
}
- Declare the use of the
UnityEngine.SceneManagementlibrary. - Create a public
IEnumeratornamedFadeAndLoadScene()with two parameters:FadeDirection _fadeDirectionandstring _sceneToLoad.- Enable the
fadeOutUIImageto display the black image. - Use the
Fade(_fadeDirection)coroutine. - Load the desired scene using
SceneManager.LoadScene(_sceneToLoad). - This process fades in the black image and loads the specified scene.
- Enable the
- In the
UIManagerscript, create a public variable calledsceneFaderof typeSceneFaderand set it in theAwakefunction usingGetComponentInChildren<SceneFader>()to obtain a reference to theSceneFaderscript.
SceneFader.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
public class SceneFader : MonoBehaviour
{
[SerializeField] private float fadeTime;
private Image fadeOutUIImage;
public enum FadeDirection
{
In,
Out
}
private void Awake()
{
fadeOutUIImage = GetComponent<Image>();
}
public IEnumerator Fade(FadeDirection _fadeDirection)
{
float _alpha = _fadeDirection == FadeDirection.Out ? 1 : 0;
float _fadeEndValue = _fadeDirection == FadeDirection.Out ? 0 : 1;
if(_fadeDirection == FadeDirection.Out)
{
while(_alpha >= _fadeEndValue)
{
SetColorImage(ref _alpha, _fadeDirection);
yield return null;
}
fadeOutUIImage.enabled = false;
}
else
{
fadeOutUIImage.enabled = true;
while (_alpha <= _fadeEndValue)
{
SetColorImage(ref _alpha, _fadeDirection);
yield return null;
}
}
}
public IEnumerator FadeAndLoadScene(FadeDirection _fadeDirection, string _sceneToLoad)
{
fadeOutUIImage.enabled = true;
yield return Fade(_fadeDirection);
SceneManager.LoadScene(_sceneToLoad);
}
void SetColorImage(ref float _alpha, FadeDirection _fadeDirection)
{
fadeOutUIImage.color = new Color(fadeOutUIImage.color.r, fadeOutUIImage.color.g, fadeOutUIImage.color.b, _alpha);
_alpha += Time.deltaTime * (1 / fadeTime) * (_fadeDirection == FadeDirection.Out ? -1 : 1);
}
}
UIManager.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class UIManager : MonoBehaviour
{
public SceneFader sceneFader;
public static UIManager Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
DontDestroyOnLoad(gameObject);
sceneFader = GetComponentInChildren<SceneFader>();
}
}
- Go back to the
SceneTransitionscript and add the following line of code:- This triggers the
Scene Faderto fade out each time a scene starts. StartCoroutine(UIManager.Instance.sceneFader.Fade(SceneFader.FadeDirection.Out));
- This triggers the
- Replace the
SceneManager.LoadSceneline with the following code:StartCoroutine(UIManager.Instance.sceneFader.FadeAndLoadScene(SceneFader.FadeDirection.In, transitionTo));- This calls the
SceneFadercoroutine and initiates the scene transition with the specifiedFadeDirectionand scene to transition to.
- Test the fading effect in the Unity editor and observe the results.
SceneTransition.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
public class SceneTransition : MonoBehaviour
{
[SerializeField] private string transitionTo; //Represents the scene to transition to
[SerializeField] private Transform startPoint; //Defines the player's entry point in the scene
[SerializeField] private Vector2 exitDirection; //Specifies the direction for the player's exit
[SerializeField] private float exitTime; //Determines the time it takes for the player to exit the scene transition
// Start is called before the first frame update
private void Start()
{
if(GameManager.Instance.transitionedFromScene == transitionTo)
{
PlayerController.Instance.transform.position = startPoint.position;
StartCoroutine(PlayerController.Instance.WalkIntoNewScene(exitDirection, exitTime));
}
StartCoroutine(UIManager.Instance.sceneFader.Fade(SceneFader.FadeDirection.Out));
}
private void OnTriggerEnter2D(Collider2D _other)
{
if (_other.CompareTag("Player"))
{
GameManager.Instance.transitionedFromScene = SceneManager.GetActiveScene().name;
SceneManager.LoadScene(transitionTo);
PlayerController.Instance.pState.cutscene = true;
PlayerController.Instance.pState.invincible = true;
StartCoroutine(UIManager.Instance.sceneFader.FadeAndLoadScene(SceneFader.FadeDirection.In, transitionTo));
}
}
}
5. Creating Lighting for our Cave Scenes
2D lighting in Unity is a rendering technique used to create dynamic lighting effects in 2D games. It adds depth and atmosphere by simulating realistic shadows, ambient lighting, and dynamic changes based on light sources. Unity’s built-in support through the Universal Rendering Pipeline allows developers to control light intensity, colour, and position, creating visually stunning environments. The system integrates with shaders and materials, enabling advanced effects like light blending and colour grading. Overall, 2D lighting enhances the visual quality and the immersion of 2D games.
a. Adding Adding 2D Lights to our Scene
So to get 2D lights into our project we’ll have to switch our render pipeline over to the Universal Rendering Pipeline.
- Open the Package Manager by going to Window -> Package Manager.
- Find and Install the URP package from the Unity registry in the Package Manager.
- Once the package installation is complete, right-click on the project tab and select Create -> Rendering -> URP Asset (2D Renderer).
- In your Unity project, go to Edit -> Project Settings.
- In the Project Settings window, navigate to Graphics.
- Under Scriptable Render Pipeline Settings, click on the Custom dropdown menu and choose UniversalRenderPipelineAsset.
- Create a new material and set it to Universal Rendering Pipeline -> 2D -> Sprite-Lit-Default material.
- Now Change all our Sprite Renderer materials to the new URP sprite material:
- Search for Sprite Renderers by typing t:SpriteRenderer in the Hierarchy search bar.
- Highlight all the game objects you find.
- Replace their sprite materials with the newly created material.
- Don’t forget to update the sprite material of your prefabs as well.
In our pursuit of creating an immersive gaming experience, paying attention to lighting can significantly enhance the atmosphere of our game. Let’s explore some key steps to achieve the desired lighting effects within our cave-themed scenes:
- Establish the Global Light 2D: To set the overall lighting tone in our cave scene, begin by adding a Global Light 2D.
- Right-click the hierarchy and select Light -> Global Light 2D
- Rename the new Light source as Global Light 2D so that you know that this specifically is you global light
- While we aim for a dark ambience to match the cave environment, it’s important to strike a balance that allows players to clearly navigate the game. Adjust the light settings accordingly.
- Highlight Scene Transitions: Drawing attention to scene transitions is crucial for seamless gameplay. Let’s enhance the visibility of these transitions using spotlights within the Scene Transition prefab. Follow these steps:
- Add a Light 2D component to the Scene Transition prefab.
- Set it to Spot Increase the size and extend the reach of the spotlight to make it more noticeable.
- Adjust the colour and intensity of the spotlight to create a visually striking effect.
- Position the spotlight in areas where scene transitions occur, ensuring it clearly indicates the presence of a transition.
- Create Ambient Lighting: To enhance the realism and depth of our Cave_1 scene, let’s introduce free-form lights. These lights simulate light streaming through cracks in the cave’s ceiling, adding an atmospheric touch. The advantage of free-form lights is the ability to control the shape of the light source, allowing for dynamic and well-lit scenes. Follow these steps:
- Place free-form lights strategically in the Cave_1 scene.
- Adjust the intensity, colour, and range of each free-form light to achieve the desired effect.
- Experiment with different shapes and positions to create interesting light patterns and shadows.
It’s worth noting that, for the purpose of brevity in this article, we will focus on ensuring appropriate brightness in Cave_2 and Cave_3 using global lighting, no too bright as we are in a cave enviroment, while also not being too dark asa we want the player to able to clearly see the enviroment. However, don’t hesitate to further customize and expand upon the lighting in these scenes, tailoring them to your desired effect.
By implementing these lighting techniques, we can elevate the visual experience of our game, immersing players in a captivating and atmospheric cave environment.
b. Fixing The Invincibility Flash Bug
When transitioning to URP, we encounter an issue where the invincibility flashing no longer works due to the sprite material color not changing. To address this, we implement the following solution:
Here’s the step-by-step process:
- Create the following:
privateboolvariable:canFlash
- Coroutine:
Flash()
- Within the
Flash()coroutine:- Toggle the sprite renderer’s visibility:
sr.enabled = !sr.enabledSetcanFlashto falseWait for 0.1f seconds:yield return new WaitForSeconds(0.05f)SetcanFlashback to true
- Toggle the sprite renderer’s visibility:
- Modify the
FlashWhileInvincible()method:- Check the following conditions:
- If the player is invincible (
pState.invincible) - If the time scale is above 0.2 (
Time.timeScale > 0.2)
- If the player is invincible (
- If
canFlashis true, initiate theFlash()coroutine:StartCoroutine(Flash()) - Otherwise, ensure that the sprite renderer is always enabled:
sr.enabled = true
- Check the following conditions:
PlayerController.cs
using UnityEngine.UIElements;
using UnityEngine.UI;
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 int jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private int 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;
float castOrHealTimer;
[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;
private bool canFlash = true;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
DontDestroyOnLoad(gameObject);
}
// 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;
Health = maxHealth;
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()
{
if (pState.cutscene) return;
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 || pState.cutscene) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
if (Input.GetButton("Cast/Heal"))
{
castOrHealTimer += Time.deltaTime;
}
else
{
castOrHealTimer = 0;
}
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-1, transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(1, 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;
int _dir = pState.lookingRight ? 1 : -1;
rb.velocity = new Vector2(_dir * 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;
}
public IEnumerator WalkIntoNewScene(Vector2 _exitDir, float _delay)
{
pstate.invincible = true;
//If exit direction is upwards
if(_exitDir.y > 0)
{
rb.velocity = jumpForce * _exitDir;
}
//If exit direction requires horizontal movement
if(_exitDir.x != 0)
{
xAxis = _exitDir.x > 0 ? 1 : -1;
Move();
}
Flip();
yield return new WaitForSeconds(_delay);
pstate.invincible = false;
pState.cutscene = false;
}
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;
}
IEnumerator Flash()
{
sr.enabled = !sr.enabled;
canFlash = false;
yield return new WaitForSeconds(0.1f);
canFlash = true;
}
void FlashWhileInvincible()
{
sr.material.color = pState.invincible ? Color.Lerp(Color.white, Color.black, Mathf.PingPong(Time.time * hitFlashSpeed, 1.0f)) : Color.white;
if (pState.invincible)
{
if(Time.timeScale > 0.2 && canFlash)
{
StartCoroutine(Flash());
}
}
else
{
sr.enabled = true;
}
}
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)
{
restoreTime = true;
yield return new WaitForSecondsRealtime(_delay);
}
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("Cast/Heal") && castOrHealTimer > 0.05f && 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.GetButtonUp("Cast/Heal") && castOrHealTimer <= 0.05f && 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 (jumpBufferCounter > 0 && coyoteTimeCounter > 0 && !pState.jumping)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
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 > 3)
{
pState.jumping = false;
rb.velocity = new Vector2(rb.velocity.x, 0);
}
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--;
}
}
}
By incorporating the time scale condition, we ensure that the player starts flashing only when the time scale is relatively high, preventing frustration and difficulty in locating the player on-screen during moments of low time scale.
Now, when you test this out, we should have a player that flashes when the player gets hit.
6. Conclusion
And that wraps up part 5 of our tutorial series! If you like to, you can also download the project files for the work we have done up to this part.
In the next instalment, we’ll take our game’s presentation to the next level by upgrading our camera to emulate the features found in Hollow Knight. Get ready for an enhanced gaming experience!
But that’s not all! We have exciting additions in store for you:
- Introducing a flying ranged enemy that will test your combat skills from a distance.
- Unleashing an enemy that charges at you creating thrilling and intense encounters.
- Adding challenging platforming elements like spikes to spice up the gameplay.
We’re just getting started, and there’s so much more to come! Thank you for following along and watching our tutorial series. We appreciate your support and dedication. Stay tuned for the next video, where we’ll continue to expand and refine our Metroidvania game. See you soon!
Here’s all the work we did today:
GameManager.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class GameManager : MonoBehaviour
{
public string transitionedFromScene;
public static GameManager Instance { get; private set; }
private void Awake()
{
if(Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
DontDestroyOnLoad(gameObject);
}
}
UIManager.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class UIManager : MonoBehaviour
{
public SceneFader sceneFader;
public static UIManager Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
DontDestroyOnLoad(gameObject);
sceneFader = GetComponentInChildren<SceneFader>();
}
}
SceneFader.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
public class SceneFader : MonoBehaviour
{
[SerializeField] private float fadeTime;
private Image fadeOutUIImage;
public enum FadeDirection
{
In,
Out
}
void Awake()
{
fadeOutUIImage = GetComponent<Image>();
}
public IEnumerator Fade(FadeDirection _fadeDirection)
{
float _alpha = _fadeDirection == FadeDirection.Out ? 1 : 0;
float _fadeEndValue = _fadeDirection == FadeDirection.Out ? 0 : 1;
if(_fadeDirection == FadeDirection.Out)
{
while(_alpha >= _fadeEndValue)
{
SetColorImage(ref _alpha, _fadeDirection);
yield return null;
}
fadeOutUIImage.enabled = false;
}
else
{
fadeOutUIImage.enabled = true;
while (_alpha <= _fadeEndValue)
{
SetColorImage(ref _alpha, _fadeDirection);
yield return null;
}
}
}
public IEnumerator FadeAndLoadScene(FadeDirection _fadeDirection, string _sceneToLoad)
{
fadeOutUIImage.enabled = true;
yield return Fade(_fadeDirection);
SceneManager.LoadScene(_sceneToLoad);
}
void SetColorImage(ref float _alpha, FadeDirection _fadeDirection)
{
fadeOutUIImage.color = new Color(fadeOutUIImage.color.r, fadeOutUIImage.color.g, fadeOutUIImage.color.b, _alpha);
_alpha += Time.deltaTime * (1 / fadeTime) * (_fadeDirection == FadeDirection.Out ? -1 : 1);
}
}
SceneTransition.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
public class SceneTransition : MonoBehaviour
{
[SerializeField] private string transitionTo; //Represents the scene to transition to
[SerializeField] private Transform startPoint; //Defines the player's entry point in the scene
[SerializeField] private Vector2 exitDirection; //Specifies the direction for the player's exit
[SerializeField] private float exitTime; //Determines the time it takes for the player to exit the scene transition
// Start is called before the first frame update
private void Start()
{
if(GameManager.Instance.transitionedFromScene == transitionTo)
{
PlayerController.Instance.transform.position = startPoint.position;
StartCoroutine(PlayerController.Instance.WalkIntoNewScene(exitDirection, exitTime));
}
StartCoroutine(UIManager.Instance.sceneFader.Fade(SceneFader.FadeDirection.Out));
}
private void OnTriggerEnter2D(Collider2D _other)
{
if (_other.CompareTag("Player"))
{
GameManager.Instance.transitionedFromScene = SceneManager.GetActiveScene().name;
PlayerController.Instance.pState.cutscene = true;
PlayerController.Instance.pState.invincible = true;
StartCoroutine(UIManager.Instance.sceneFader.FadeAndLoadScene(SceneFader.FadeDirection.In, transitionTo));
}
}
}
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;
public bool cutscene = false;
}
PlayerController.cs
using UnityEngine.UIElements;
using UnityEngine.UI;
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 int jumpBufferCounter = 0; //stores the jump button input
[SerializeField] private int 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;
float castOrHealTimer;
[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;
private bool canFlash = true;
//creates a singleton of the PlayerController
public static PlayerController Instance;
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
DontDestroyOnLoad(gameObject);
}
// 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;
Health = maxHealth;
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()
{
if (pState.cutscene) return;
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 || pState.cutscene) return;
Recoil();
}
void GetInputs()
{
xAxis = Input.GetAxisRaw("Horizontal");
yAxis = Input.GetAxisRaw("Vertical");
attack = Input.GetButtonDown("Attack");
if (Input.GetButton("Cast/Heal"))
{
castOrHealTimer += Time.deltaTime;
}
else
{
castOrHealTimer = 0;
}
}
void Flip()
{
if (xAxis < 0)
{
transform.localScale = new Vector2(-1, transform.localScale.y);
pState.lookingRight = false;
}
else if (xAxis > 0)
{
transform.localScale = new Vector2(1, 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;
int _dir = pState.lookingRight ? 1 : -1;
rb.velocity = new Vector2(_dir * 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;
}
public IEnumerator WalkIntoNewScene(Vector2 _exitDir, float _delay)
{
pstate.invincible = true;
//If exit direction is upwards
if(_exitDir.y > 0)
{
rb.velocity = jumpForce * _exitDir;
}
//If exit direction requires horizontal movement
if(_exitDir.x != 0)
{
xAxis = _exitDir.x > 0 ? 1 : -1;
Move();
}
Flip();
yield return new WaitForSeconds(_delay);
pstate.invincible = false;
pState.cutscene = false;
}
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;
}
IEnumerator Flash()
{
sr.enabled = !sr.enabled;
canFlash = false;
yield return new WaitForSeconds(0.1f);
canFlash = true;
}
void FlashWhileInvincible()
{
if (pState.invincible)
{
if(Time.timeScale > 0.2 && canFlash)
{
StartCoroutine(Flash());
}
}
else
{
sr.enabled = true;
}
}
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)
{
restoreTime = true;
yield return new WaitForSecondsRealtime(_delay);
}
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("Cast/Heal") && castOrHealTimer > 0.05f && 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.GetButtonUp("Cast/Heal") && castOrHealTimer <= 0.05f && 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 (jumpBufferCounter > 0 && coyoteTimeCounter > 0 && !pState.jumping)
{
rb.velocity = new Vector3(rb.velocity.x, jumpForce);
pState.jumping = true;
}
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 > 3)
{
pState.jumping = false;
rb.velocity = new Vector2(rb.velocity.x, 0);
}
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--;
}
}
}