When the time to position the assets came, I first had to painstakingly move them in relation to one another (this was a slow process that took quite some time). After I had a bunch of walls placed that I could use to add gameobjects that could act as `SnapPoints` (this points can be seen in the hierarchy image added above), I was able to speed the process up and I could just drop a prefab inside a point, reset its transform values and then remove it from the point and place it in its corresponding place in the hierarchy.
Painstakingly positioning process:
Positioning with SnapPoints:
I think that a great choice to further speed this process could be creating a tool to quickly place the prefabs and I will definitely try it when I get back to this project.
Once I had everything setup, I started moving my player around the walls and I quickly realized that I needed to add rounded courners to my walls in order to improve my player's movement while hitting the colliders. I made it by using `Polygon Collider 2D` which allows the creation of custom colliders in any form we like, we can just drag points around and quickly get any desired shape.
`Tip: Use Polygon Collider 2D component to create custom colliders and add rounded corners to improve your player's movement while hitting those colliders.`
The last detail that I had to add to the walls was an extra gameobject with a collider marked as isTrigger and also tagged as `Wall`, this due to the fact that since the version 0.1 the projectiles are using the collision method `OnTriggerEnter2D` and are also comparing the tag `Wall` to check if they hit one.
`Tip: Make sure to create prefabs of your assets from the beginning, if you ever need to make changes and already have a lot of assets placed everywhere, you will thank yourself when you simply change a prefab and all of your duplicated prefabs change as well.`
---
### FX - Dash Skill After Images ([ToC↑](#home))
I had this effect in mind since I started making this project, and after I had the dash skill ready, everything was set to start learning how to achieve it.
From playing lots of games and seeing some video tutorials with the after images effect, I got a clear view of how to do it, however, there was a little problem... all of the references I saw were using a single sprite for the whole character and my player had a bunch of sprites linked together to make the full body behaviour.
At first I thought about painstakingly adding 3 after images sprites (with a different material for each one) to each part of the player's body, but that would take me like forever and if I needed to make a change it would take me forever². In order to avoid adding the sprites manually, what I ended up doing was a series of classes that would add them for me at runtime and group them as childs of gameobjects that would also be child of a main gameobject called `AfterImages`.
To make this small system, I wrote 5 classes. The first class, that's directly attached to the player's sprites, is called `AfterImageGenerator`, and the process that starts on this class Awake method and goes all the way to the PlayerController, goes as follows:
0. The AfterImageGenerator first finds the second class `AfterImageMaterials` and stores it.
1. Then it creates a gameobject named `GameobjectName_AfterImage_Group` that comes with the third class `AfterImageGroup` attached to it.
2. Then this same class instantiates N amount of the fourth class `AfterImage`, it also sets properties (e.g. a material from the AfterImageMaterials class) for the instantiated classes and adds them to the AfterImage[] array inside the `AfterImageGroup` class.
3. When an `AfterImageGroup` is created, it immediatly finds the fifth class `AfterImageHandler` and adds itself to a list of `AfterImageGroup` inside the class.
4. And all this ends in having a simple method in the fifth class which I called `SetActiveAfterImages()`, and this method is called by the class `PlayerSkills` when the `Dash` skill is called by the `PlayerController`.
`Note: There are lots of comments on each part of the process to give you an idea of what's happening inside the code.`
### Pause Controller ([ToC↑](#home))
In the first version I was handling the pause action inside the `PlayerController`, that was not a good choice, but I did it like that because I simply wanted to stop everything to be able to take screenshots.
Now I handle it with the class `PauseController` that has a public static bool called `isGamePaused` which I set active by checking if the key `Pause` from `TadaInput` was pressed. This class also has two public `UnityEvent` to quickly set actions in the Inspector tab (e.g. adding an events to enable/disable a paused menu).
This is the whole code:
```c#
using UnityEngine;
using UnityEngine.Events;
public class PauseController : MonoBehaviour
{
public UnityEvent onGamePause;
public UnityEvent onGameResume;
public static bool isGamePaused;
private void Update()
{
if (TadaInput.GetKeyDown(TadaInput.ThisKey.Pause))
{
if (!isGamePaused)
{
isGamePaused = true;
OnGamePause();
return;
}
isGamePaused = false;
OnGameResume();
}
}
private void OnGamePause()
{
Time.timeScale = 0;
// Pause audio
AudioListener.pause = true;
// If there is at least one event added in the Inspector tab, Invoke it.
if (onGamePause != null)
onGamePause.Invoke();
}
private void OnGameResume()
{
Time.timeScale = 1;
// Resume audio
AudioListener.pause = false;
// If there is at least one event added in the Inspector tab, Invoke it.
if (onGameResume != null)
onGameResume.Invoke();
}
}
```
---
### TadaInput (Custom Input Manager) ([ToC↑](#home))
Since I started making games I always wanted to create my own Input Manager that could be used in the same way as Unity's `Input` class (e.g. Input.GetkeyDown(Keycode.AnyKey)) and I think that I managed to create a system that works great for what I needed in this version.
The basic idea of this class is quite simple, first I have an enum with keys `ThisKey`, then I have methods to store the inputs from Unity's `Input` as `ThisKey` in three different arrays (one for Key, one for KeyDown and one for KeyUp) and then I use three methods (GetKey, GetKeyDown and GetKeyUp) to compare a given `ThisKey` against those arrays and at the end they return true or false. The actual implementation of the idea took a while, I had a bunch of bugs at the beggining, but after some trials and editing I ended up with a behaviour that works just like I wanted it to.
Now I'll talk about the actual code:
- This is how the basic properties are:
```C#
public enum ThisKey
{
None, MoveLeft, MoveRight, MoveUp, MoveDown, PrimaryAction, SecondaryAction,
PreviousWeapon, NextWeapon, PreviousUseRate, NextUseRate, Xbox360RightTrigger,
Xbox360LeftTrigger, MouseAnyMovement, Dash, Pause, Count
}
private static ThisKey[] currentKeys;
private static ThisKey[] currentKeysDown;
private static ThisKey[] currentKeysUp;
private static bool[] currentAxisDown;
```
> The values in `ThisKey` enum can be on any order, the system will work without any issue.
- The first thing that's called on Awake() is the method `InitializeInputArrays()` which uses `ThisKey.Count + 1` as the length of the arrays and adds a `None` key to each of the elements of the arrays.
```c#
private static void InitializeInputArrays()
{
int length = (int)ThisKey.Count + 1;
currentKeys = new ThisKey[length];
currentKeysDown = new ThisKey[length];
currentKeysUp = new ThisKey[length];
currentAxisDown = new bool[length];
for (int i = 0; i < length; i++)
{
currentKeys[i] = ThisKey.None;
currentKeysDown[i] = ThisKey.None;
currentKeysUp[i] = ThisKey.None;
currentAxisDown[i] = false;
}
}
```
- Next we have the three methods to store the keys:
```c#
private static void StoreCurrentKey(ThisKey key)
{
currentKeys[(int)key] = key;
}
private static void StoreCurrentKeyDown(ThisKey key)
{
currentKeysDown[(int)key] = key;
}
private static void StoreCurrentKeyUp(ThisKey key)
{
currentKeysUp[(int)key] = key;
currentKeysDown[(int)key] = ThisKey.None;
currentKeys[(int)key] = ThisKey.None;
}
```
> Notices how I use (int)key to convert the enum ThisKey key into an int and use that as the Index, this is how I make this system work without worrying about the enum values order, each one of the values have their own reserved space inside the arrays.
Sample of how a sigle key is stored:
```c#
// Down
if (Input.GetKeyDown(KeyCode.Space) || Input.GetKeyDown(KeyCode.Joystick1Button5))
StoreCurrentKeyDown(ThisKey.Dash);
// Up
if (Input.GetKeyUp(KeyCode.Space) || Input.GetKeyUp(KeyCode.Joystick1Button5))
StoreCurrentKeyUp(ThisKey.Dash);
```
- Next we have a method to store axis inputs as simple keys. This is something that is missing from Unity's `Input` system and I needed it to use my xbox controller trigger as a simple button (This one was tricky to make, but I eventually got it working).
```c#
private static void StoreCurrentAxisAsKeyType(ThisKey key, float rawAxisValue)
{
int index = (int)key;
if (rawAxisValue > 0)
{
if (!currentAxisDown[index]) // DOWN
{
currentAxisDown[index] = true;
StoreCurrentKeyDown(key);
}
StoreCurrentKey(key); // HOLD
}
if (rawAxisValue == 0 && currentAxisDown[index]) // UP
{
currentAxisDown[index] = false;
StoreCurrentKeyUp(key);
}
}
```
- Next we have three methods that works just like Unity's `Input` and can be used from any other class to actually check if the keys are being used.
**GetKey**
```c#
public static bool GetKey(ThisKey key)
{
int index = (int)key;
if (currentKeys[index] == key)
{
if (debug)
Debug.Log("Key: " + key.ToString());
return true;
}
return false;
}
```
**GetKeyDown**
```c#
public static bool GetKeyDown(ThisKey key)
{
int index = (int)key;
if (currentKeysDown[index] == key)
{
currentKeysDown[index] = ThisKey.None;
if (debug)
Debug.Log("KeyDown: " + key.ToString());
return true;
}
return false;
}
```
**GetKeyUp**
```c#
public static bool GetKeyUp(ThisKey key)
{
int index = (int)key;
if (currentKeysUp[index] == key)
{
currentKeysUp[index] = ThisKey.None;
if (debug)
Debug.Log("KeyUp: " + key.ToString());
return true;
}
return false;
}
```
Sample of how this methods are used by other classes:
```c#
if (TadaInput.GetKey(TadaInput.ThisKey.PrimaryAction))
_WeaponHandler.UseWeapon(WeaponHandler.ActionType.Primary);
```
- Apart from all the methods mentioned above, `TadaInput` also stores inputs like mouse pixel position, mouse world position and some other properties.
`Note: Right now this class works just great for what I had intended and it was a great learning experiment, but in the future I will need to consider and implement a lot of things like remapping keys at runtime or supporting other types of controllers.`
---
### Physics ([ToC↑](#home))
To control Unity's 2D physics I made the class `PhysicsHandler`. This class stores a `Rigidbody2D` on `Awake()` to use it on public methods for handling velocity and force, it also stores a `Collider2D` to enable/disable it on a public method. The idea of this class is to use it as base class to create derived classes that inherit the base methods, and then add more behaviours using those inherited methods.
So far I've only used this class to create the class `PlayerPhysics` which handles the movement of the player by using the method `SetVelocity`.
Here is the whole code:
```c#
using UnityEngine;
[RequireComponent(typeof(Rigidbody2D))]
public class Physics2DHandler : MonoBehaviour
{
protected Rigidbody2D _RigidBody;
protected Collider2D _Collider;
protected virtual void Awake()
{
TryGetComponent(out _RigidBody);
TryGetComponent(out _Collider);
}
public void SetActiveCollider(bool value)
{
if (_Collider != null)
_Collider.enabled = value;
}
public void SetRigidbodyType(RigidbodyType2D type)
{
if (_RigidBody != null)
_RigidBody.bodyType = type;
}
/// )
- **PlayerShoulderMain:** This class only exists to act as a realiable way to let other classes find it (e.g. CrosshairJoystick). The actual behaviour of the main shoulder is handled by the rotation utility `LookAt2Dv2` which makes it point its x axis towards the crosshair position.
)
> Debug line that goes from the main shoulder to the crosshair position.
- **PlayerShoulderSecondary:** This class uses the `Crosshair AimDirection` and other properties like rate, min offset angle and max offset angle to determine an offset angle that will be added to the secondary shoulder as an extra rotation. This is an important part of the behaviour that controls the rotation of the shoulders, with the correct values both shoulders match their rotation in relation to the weapon that's being held by the character.
- **PlayerMaterials:** This class will be used to control all the behaviours related to the player's materials. At the moment is used to control the property `Color Intensity` from the custom shader `Unlit_Sprite_HDR_ColorIntensity` which I created using `Shader Graph` to make the player glow for a short duration of time (used when dashing).
> In this capture the dash is disabled to showcase the highlight without any movement.
- **PlayerPhysics:** This class is a derived class of `PhysicsHandler`. At the moment it does three functions, the first one is to use the base method `SetVelocity (vector2 direction, float speed)` to move the player to the direction `TadaInput.MoveAxisRawInput` by a float called `_MoveSpeed` and the second is using the method `OnTriggerEnter2D` to find collisions when enterring colliders marked as `isTrigger` and to compare their tags to check if they are named `EnvironmentTrigger` (with the purpose of setting active the environment objects if a `EnvironmentObjectTrigger` is found). The third function is providing the `PhysicsHandler` methods to create skills inside the class called `PlayerSkills`.
- **PlayerSkills:** I use this class along with the classes `PlayerPhysics`, `PlayerMaterials`, `AfterImageHandler` and `SoundHandlerGlobal`, and also an array of `TrailRenderer`, to create the `Dash` skill.
The way it works is really simple and I'll just add the code here with comments so you can have an idea of how it works:
```c#
using System.Collections;
using UnityEngine;
public class PlayerSkills : MonoBehaviour
{
public TrailRenderer[] dashTrails;
[SerializeField] private float dashForce = 5f;
public SoundHandlerGlobal dashSFXHandler;
private PlayerPhysics _PlayerPhysics;
private PlayerMaterials _PlayerMaterials;
private AfterImageHandler _AfterImageHandler;
private bool canDash;
private const float DASH_DURATION = 0.2f;
private void Awake()
{
_AfterImageHandler = FindObjectOfType3. If the player presses the secondary action button the current weapon `SecondaryAction` method is called and does the following: ```c# public override void SecondaryAction(bool value) { base.SecondaryAction(value); // The purpose of this action is to let the player hold the secondary action button to make the bool // isReceivingInput true, which in turn enables a timer and a series of actions to ultimately launch the // secondary projectile. // After firing the projectile, canUse is set to false and because the player can continuously call this method, // we use this to stop isReceivingInput from getting a true value. if (!canUse) { // Cancel inputs after use. isReceivingInput = false; return; } // We stop the code here if one of the needed variables is missing. if ((secondaryProjectile == null || chargingPFX == null || chargingSFX == null)) { Debug.LogWarning(gameObject.name + ": missing prefabs!"); return; } // We make it true if the player is pressing the secondary action button or false if not. // When it's true, it activates the actions on the Update method of this class. isReceivingInput = value; } ```
3.1. When `isReceivingInput` is `true` a timer is enabled and a sequence of actions are called if certain conditions are met. ```c# if (isReceivingInput) { // Execute the initial actions that take place in the first frame after isReceivingInput is set to true. OnChargingStart(); // Timer: Increase the value of chargingTime by adding Time.deltaTime on each frame. chargingTime += Time.deltaTime; // Update OnCharging actions and pass chargingTime as argument. OnCharging(chargingTime); // If charging time is equal or greater than the constant charge duration, execute the last actions. if (chargingTime >= CHARGE_DURATION) OnChargingEnd(); } ```
3.2. The first action that gets called is `OnChargingStart` and it's used to do the following actions: ```c# private void OnChargingStart() { // This actions can only be executed if isCharging is false. if (!isCharging) { // Play the charging animation if WeaponAnim_ShootProjectileCanCharge is available. if (anim != null) anim.PlayAnimation(WeaponAnim_ShootProjectileCanCharge.Animation.Charging); // We set it to true to avoid calling this method more than once. isCharging = true; // Make the camera Shake. CameraShake.Shake(duration: CHARGE_DURATION, shakeAmount: 0.065f, decreaseFactor: 1f); // Enable the charging visual effects. chargingPFX.SetActive(true); // Play the first sound of SoundHandlerLocal. chargingSFX.PlaySound(); } } ``` 3.3. Then the `OnCharging` action which is simply scaling the visual effects is called and updated each frame until `chargingTime` reaches `CHARGE_DURATION`. ```c# private void OnCharging(float t) { // Increase the size of the charging fx to enhance it with a feeling a anticipation. chargingPFX.transform.localScale = Vector2.one * t; } ```
3.4. If `chargingTime` reaches `CHARGE_DURATION`, the last method `OnChargingEnd` is called and the secondary projectile is fired. These are the actions that take place when this method is called: ```c# private void OnChargingEnd() { // Play the charged shot animation if WeaponAnim_ShootProjectileCanCharge is available. if (anim != null) anim.PlayAnimation(WeaponAnim_ShootProjectileCanCharge.Animation.ChargedShot); // Set it to false to allow OnChargingStart to be called again. isCharging = false; // Set it to false to stop the player from making isReceivingInput true if it's holding the secondary action button. canUse = false; // Reset the timer to allow correctly restarting the charging action. chargingTime = 0.0f; // Make the camera Shake by a greater value. CameraShake.Shake(duration: 0.2f, shakeAmount: 1f, decreaseFactor: 3f); // Enable the projectile. secondaryProjectile.SetActive(true); // Call the method Fire on the projectile to launch it towards the crosshair direction. secondaryProjectile.Fire(); // Make it null to give room to a new instantiated projectile. secondaryProjectile = null; // Reset the scale of the charging visual fx. chargingPFX.transform.localScale = Vector2.one; // Disable the charge visual fx. chargingPFX.SetActive(false); } ```
3.5. Lastly if the secondary action is charging and the player releases the corresponding button, the method `OnChargeCancel` gets called and does the following actions to reset the weapon, allowing the player to use the charging action again right from the start: ```c# private void OnChargeCancel() { // Return to Idle animation if WeaponAnim_ShootProjectileCanCharge is available. if (anim != null) anim.PlayAnimation(WeaponAnim_ShootProjectileCanCharge.Animation.Idle); // Is set to false to allow OnChargingStart to be called again. isCharging = false; // Is set to zero to reset the timer so that it can correctly count the time again. chargingTime = 0.0f; // Stop the camera from shaking. CameraShake.Shake(0f, 0f, 0f); // Stop the charging SoundHandlerLocal sounds. chargingSFX.StopSound(); // Reset the scale of the charging visual fx. chargingPFX.transform.localScale = Vector2.one; // Disable the charging visual fx. chargingPFX.SetActive(false); } ``` > It's important to note that using Instantiate() to shoot projectiles is a great choice for rapid prototyping and testing, but its a bad move when it comes to actually creating a good system, constantly creating new GameObjects and destroying them would do no good to the garbage collection system. A good choice would be creating a pool system that has pre-cloned prefabs which can be used without destroying them, they just get enabled when called and disabled when they are "destroyed". I had my focus on all other parts of this project that I wanted to improve, so at the I didn't have enough time to implement a method like a pooling system. > Also it's worth noting that the charging action can be reused right after OnChargingEnd is called, which I think is not the best desirable behaviour, in the future I'll introduce a short delay after use. --- ### Projectiles ([ToC↑](#home)) This class is really simple, it has three custom methods. `SetActive(bool value)` to enable/disable the `SpriteRenderer` and the `BoxCollider2D` of the projectile. `Fire()` to launch the projectile towards a Vector3 called `travelDirection` which also detaches it from its parent (weapon) and calls Destroy on itself with a specified delay time. And lastly the method `Travel()` to actually move the projectile towards `travelDirection` multiplied by a `Speed` variable. The projectile also uses the method `OnTriggerEnter2D (Collider2D collision)` to check if there was an impact, and if one is found, the projectile gets destroyed after instantiating a visual effect. > The projectiles get destroyed because I'm using instantiate to spawn them, if the pooling system is made, this should be changed to simply hide the projectiles and also reset them after a certain amount of time traveling or after an impact happens. ### Shaders ([ToC↑](#home)) There are five simple shaders made with Shader Graph, the most elaborated one is the one used for the particle effects. At first I thought I could use a simple shader like this one to add to a particle system: ![]("https://i.imgur.com/eRfhxIr.png") It works great for simple sprites, but for a particle system it doesn't. After searching for a while, I found that **particles uses the vector color of the object to actually change its color**, so without adding that part to the shader, I wouldn't be able to change the color by using the system options. After a little adjustments, this is the shader that I'm currently using for the particles: ![]("https://i.imgur.com/Ot3wpNW.png") It's basically the same, but now it adds the vertex color in the calculation and it works great with the particle systems, it also has `HDR Color` which I use to increase its intensity and make the particles glow by using the post processing fx `Bloom`. --- That's it for this version of the project. I hope you find it useful and fun to mess around with. --- ### Support ([ToC↑](#home)) If you need any help or you found an issue that would like to talk about, reach out to me at one of the following places! - Twitter @tadadosi - Reddit u/tadadosi ---
[]()
---I believe that knowledge should be free and easy to find. Not so long ago I was having a hard time figuring all this stuff out, so I started making this type of projects hoping that it will be useful to you or to anyone else who finds it.
If you would like to support my work, consider doing any of the following:
Click the image to go to itch.io and try my new game demo. (if you like it, please remember to rate it, it's a big help.)
---
### Many thanks to
- My awesome wife that encourages me every day.
- Unity for existing and being free!
- All the people who has given me great feedback and motivation.
- All the artist / programmers who are constantly making free knowlegde available.
- And anyone who's reading this :)
- P.S.: **Extra thanks if you follow my twitter account and play my game :D!**
---
### Credits ([ToC↑](#home))
#### Scripts
- CameraShake by ftvs on Github
- Singleton pattern MIT Licence @ Unity Community
#### Sound FX (Freesound.org)
- Short Laser Shots by Emanuele_Correani - CC-BY-3.0
- Sci-Fi Force Field Impact 15 by StormwaveAudio - CC-BY-3.0
- Sci_FI_Weapon_01 by ST303 - CC0 1.0
- SciFi Gun - Mega Charge Cannon by dpren - CC0 1.0
#### Music (Freemusicarchive.org)
- Azimutez by Sci Fi Industries - CC BY-NC-SA 3.0
#### Repo readme
- sampleREADME.md by fvcproductions on Github
- Github - Creating and highlighting code blocks
---
### License
- MIT license
- The MIT License only applies to the code tagged with "by Tadadosi" and the Unity project setup in this repo, it does not include the sprites and the audio files.
- Pixel art sprites are free for personal use.