init

Assets/Scripts/Player/DistanceConstraint.cs

@@ -0,0 +1,17 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class DistanceConstraint : MonoBehaviour{
+
+    public Transform source;
+    public float maxDistance;
+    [Range(0, 1)] public float maxHeight = .15f;
+
+    void Update(){
+        if ((transform.position - source.position).magnitude > maxDistance){
+            transform.position = source.position + (transform.position - source.position).normalized * maxDistance;
+            transform.localPosition = new Vector3(transform.localPosition.x, maxHeight, transform.localPosition.z);
+        }
+    }
+}

Assets/Scripts/Player/DistanceConstraint.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 95a5d012580aac74981717162f274387
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Player/DungeonIntruder.cs

@@ -0,0 +1,24 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class DungeonIntruder : MonoBehaviour
+{
+    public Room currentRoom;
+    public UnityEvent roomChange;
+
+    private void Awake()
+    {
+        roomChange = new UnityEvent();
+    }
+
+    private void OnTriggerEnter(Collider other)
+    {
+        if (other.gameObject.GetComponent<Room>() != null && other.gameObject.GetComponent<Room>()!=currentRoom)
+        {
+            currentRoom = other.gameObject.GetComponent<Room>();
+            roomChange.Invoke();
+        }
+    }
+}

Assets/Scripts/Player/DungeonIntruder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 87e63aad25b099d4d9350db316e276ef
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Player/FrisbieController.cs

@@ -0,0 +1,184 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class FrisbieController : MonoBehaviour, IPooledObject{
+
+    [System.Serializable] public enum FrisbieType { Default, Explosive, Boomerang }
+    public FrisbieType frisbieType = default;
+
+    [Space]
+    [SerializeField, Range(0, 3)] float damageVelocityThreshold = 1.5f;
+
+    [Header("Default")]
+    [SerializeField] float speed = 10f;
+    Rigidbody rb;
+    [SerializeField] Transform frisbie = default;
+    float heightVelocity;
+    public PhysicMaterial defaultMaterial;
+
+    [Header("Explosive")]
+    [SerializeField] float explosiveSpeed = 5f;
+    private bool canExplode = false;
+    public float explosionSpeedThreshold = 0.5f;
+    public float explosionRad = 1;
+    public float explosionBlastSpeed = 20;
+    public SphereCollider explosionCol;
+    public PhysicMaterial explosiveMaterial;
+
+    [Header("Boomerang")]
+    [SerializeField] float boomerangSpeed = 5f;
+    public float boomerangReturnStrength = 5;
+    private Vector3 boomerangReturnDir = Vector3.zero;
+    public PhysicMaterial boomerangMaterial;
+
+    [Space]
+    [SerializeField, Range(0, 1)] float pickUpEnableDelay = .3f;
+    [SerializeField] GameObject pickUpCollider = default;
+    [SerializeField] GameObject[] disks = default;
+
+    void Awake(){
+        rb = GetComponent<Rigidbody>();
+
+        if (PlayerPrefs.HasKey("Disk")){
+            for (int i = 0; i < disks.Length; i++){
+                if (PlayerPrefs.GetInt("Disk") != i){
+                    disks[i].SetActive(false);
+                }
+            }
+        }else{
+            PlayerPrefs.SetInt("Disk", 0);
+            for (int i = 0; i < disks.Length; i++){
+                if(PlayerPrefs.GetInt("Disk") != i){
+                    disks[i].SetActive(false);
+                }
+            }
+        }
+    }
+
+    void OnValidate()
+    {
+        explosionCol.radius = explosionRad;
+    }
+
+    public void OnObjectSpawn(){
+        explosionCol.enabled = false;
+        gameObject.tag = "Disk";
+        rb.velocity = Vector3.zero;
+        switch (frisbieType)
+        {
+            case FrisbieType.Default:
+                GetComponent<Collider>().material = defaultMaterial;
+                break;
+            case FrisbieType.Boomerang:
+                GetComponent<Collider>().material = boomerangMaterial;
+                break;
+            case FrisbieType.Explosive:
+                GetComponent<Collider>().material = explosiveMaterial;
+                break;
+        }
+        boomerangReturnDir = transform.forward * -1;
+        if(pickUpCollider != null)
+            pickUpCollider.SetActive(false);
+        StartCoroutine(EnablePickUpCollider());
+    }
+    
+    public void AddForce(Vector3 velocity){
+        //rb.velocity = velocity / 2;
+        //rb.velocity = new Vector3(velocity.x, 0, velocity.z) / 2;
+        switch (frisbieType){
+            case FrisbieType.Default:
+                rb.AddForce(transform.forward.normalized * speed, ForceMode.Impulse);
+                break;
+            case FrisbieType.Explosive:
+                rb.AddForce(transform.forward.normalized * explosiveSpeed, ForceMode.Impulse);
+                break;
+            case FrisbieType.Boomerang:
+                rb.AddForce(transform.forward.normalized * boomerangSpeed, ForceMode.Impulse);
+                break;
+        }
+    }
+
+    void FixedUpdate(){
+        float velocity = rb.velocity.magnitude;
+        float positionToGo = 0;
+
+        if(velocity < damageVelocityThreshold)
+            gameObject.tag = "Untagged";
+        else
+            gameObject.tag = "Disk";
+
+        switch (frisbieType)
+        {
+            case FrisbieType.Default:
+                positionToGo = Mathf.SmoothDamp(frisbie.localPosition.y, -1 + velocity / speed, ref heightVelocity, .1f);
+                frisbie.localPosition = new Vector3(0, positionToGo, 0);
+                break;
+            case FrisbieType.Boomerang:
+                if (boomerangReturnDir != Vector3.zero)
+                    rb.AddForce(boomerangReturnDir * Mathf.Lerp(0, boomerangReturnStrength, 1), ForceMode.Acceleration);
+                else
+                {
+                    positionToGo = Mathf.SmoothDamp(frisbie.localPosition.y, -1 + velocity / speed, ref heightVelocity, .5f);
+                    frisbie.localPosition = new Vector3(0, positionToGo, 0);
+                }
+                break;
+            case FrisbieType.Explosive:
+                positionToGo = Mathf.SmoothDamp(frisbie.localPosition.y, -1 + velocity / speed, ref heightVelocity, .1f);
+                frisbie.localPosition = new Vector3(0, positionToGo, 0);
+
+                if (velocity < explosionSpeedThreshold)
+                    Kaboom();
+                break;
+        }
+    }
+
+    void Kaboom()
+    {
+        if (canExplode)
+        {
+            explosionCol.enabled = true;
+            ObjectPooler.instance.SpawnFromPool("Explosion", transform.position);
+            //Harm all enemies within explosionCol
+            if (Random.value > 0.5f)
+            {
+                ObjectPooler.instance.SpawnFromPool("DiskBits", transform.position);
+                gameObject.SetActive(false);
+            }
+            else
+            {
+                Vector3 explosionDir = Random.onUnitSphere;
+                explosionDir.y = 1;
+                explosionDir.Normalize();
+                rb.velocity = Vector3.zero;
+                AddForce(explosionDir * explosionBlastSpeed);
+            }
+            canExplode = false;
+        }
+    }
+
+    IEnumerator EnablePickUpCollider(){
+        yield return new WaitForSeconds(pickUpEnableDelay);
+        if (pickUpCollider != null)
+            pickUpCollider.SetActive(true);
+        canExplode = true;
+    }
+
+    private void OnCollisionEnter(Collision collision)
+    {
+        if (collision.gameObject.CompareTag("Wall"))
+        {
+            switch (frisbieType)
+            {
+                case FrisbieType.Default:
+                    break;
+                case FrisbieType.Boomerang:
+                    boomerangReturnDir = Vector3.zero;
+                    break;
+                case FrisbieType.Explosive:
+                    Invoke(nameof(Kaboom), .05f);
+                    break;
+            }
+        }
+    }
+}

Assets/Scripts/Player/FrisbieController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6ac47d21cb257814588f8400f884fc6f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Player/InputNameScore.cs

@@ -0,0 +1,54 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class InputNameScore : MonoBehaviour{
+
+    string scoreName;
+
+    [SerializeField] GameObject nextScreen = default;
+    [SerializeField] Percentage percentage = default;
+
+    void Awake(){
+        nextScreen.SetActive(false);
+    }
+
+    public void InputName(string name){
+        scoreName = name;
+    }
+
+    public void Submit(){
+        if(scoreName.ToCharArray().Length == 3){
+            PlayerController player = FindObjectOfType<PlayerController>();
+            AddHighscoreEntry(Mathf.RoundToInt(player.timeSurvived), player.percentage, scoreName.ToUpper(), player.bossKilled);
+            gameObject.SetActive(false);
+            nextScreen.SetActive(true);
+            percentage.UpdateSlider();
+        }
+    }
+
+    void AddHighscoreEntry(int time, int percentage, string name, bool boss){
+        HighscoreEntry highscoreEntry = new HighscoreEntry { name = name, percentage = percentage, time = time, boss = boss };
+
+        string jsonString = PlayerPrefs.GetString("HighscoreTable");
+        Highscores highscores = JsonUtility.FromJson<Highscores>(jsonString);
+
+        highscores.highscoreEntryList.Add(highscoreEntry);
+
+        string json = JsonUtility.ToJson(highscores);
+        PlayerPrefs.SetString("HighscoreTable", json);
+        PlayerPrefs.Save();
+    }
+
+    class Highscores{
+        public List<HighscoreEntry> highscoreEntryList;
+    }
+
+    [System.Serializable]
+    class HighscoreEntry{
+        public bool boss;
+        public int time;
+        public int percentage;
+        public string name;
+    }
+}

Assets/Scripts/Player/InputNameScore.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6e742fe5abd7c4b46860fdac216cd82f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Player/LoadMenu.cs

@@ -0,0 +1,13 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class LoadMenu : MonoBehaviour{
+    public void LoadLevel(){
+        Destroy(GameMaster.Instance.gameObject);
+        PlayerPrefs.DeleteKey("HP");
+        PlayerPrefs.DeleteKey("Percentage");
+        PlayerPrefs.DeleteKey("TimeSurvived");
+        Loader.Load(0);
+    }
+}

Assets/Scripts/Player/LoadMenu.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: afca2ca37a9f5d44fb386b0c01fb6051
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Player/PlayerController.cs

@@ -0,0 +1,264 @@
+using Cinemachine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class PlayerController : MonoBehaviour{
+
+    [Space]
+    [HideInInspector] public bool bossKilled;
+    [HideInInspector] public float timeSurvived;
+    public int percentage;
+
+    [SerializeField] Transform container = default;
+    Rigidbody rb;
+    [SerializeField] float speed = 6f;
+    [SerializeField] LayerMask whatIsGround = -1;
+    [SerializeField] Animator anim = default;
+    float rotationVelocity;
+    [SerializeField] ParticleSystem stepParticle = default;
+    bool walking;
+
+    [Space]
+    public int weaponSelected;
+    [SerializeField] Transform shootPos = default;
+    [SerializeField] Animator deathScreenAnim = default;
+    [SerializeField] Animator winScreenAnim = default;
+
+    [Space]
+    [SerializeField] Transform aimPos = default;
+    public PlayerHealth health;
+    Camera mainCamera;
+
+    [SerializeField, Range(0, .5f)] float timeBetweenSteps = .1f;
+    float currentStepTime;
+    bool step;
+
+    [SerializeField] ParticleSystem shootParticles = default;
+    [SerializeField] Animator getDiskIcon;
+
+    [HideInInspector]
+    public UnityEngine.Events.UnityEvent damageEv=new UnityEngine.Events.UnityEvent();
+
+    [SerializeField] CinemachineVirtualCamera trackedCam = default;
+    [SerializeField, Range(0, 1)] float camRotationSpeed = .2f;
+    [SerializeField] Transform track = default;
+    CinemachineTrackedDolly cmTrack;
+    bool dead;
+
+    [HideInInspector] public bool invencible;
+
+    bool wayToTheBoss;
+
+    // Start is called before the first frame update
+    void Awake(){
+        timeSurvived = PlayerPrefs.GetFloat("TimeSurvived", 0);
+        percentage = PlayerPrefs.GetInt("Percentage", 1);
+        rb = GetComponent<Rigidbody>();
+        weaponSelected = 1;
+        health = FindObjectOfType<PlayerHealth>();
+        mainCamera = Camera.main;
+        trackedCam.gameObject.SetActive(false);
+    }
+
+    // Update is called once per frame
+    void Update(){
+        percentage = Mathf.Clamp(percentage, 0, 100);
+        if (!wayToTheBoss && percentage >= 100){
+            wayToTheBoss = true;
+            FindObjectOfType<Portal>().bossPortal = true;
+        }
+
+        Vector3 movementInput = new Vector3(Input.GetAxisRaw("Horizontal"), 0, Input.GetAxisRaw("Vertical")).normalized;
+
+        Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);
+        RaycastHit hit;
+
+        if(Physics.Raycast(ray, out hit, 1000f, whatIsGround) && Time.timeScale != 0 && Input.GetMouseButtonDown(0) && health && health.currentHp > 0){
+            Vector3 pos = hit.point - transform.position;
+            float rotY = Mathf.Atan2(-pos.z, pos.x) * Mathf.Rad2Deg;
+            transform.rotation = Quaternion.Euler(0f, rotY + 90, 0f);
+        }
+
+        if (Input.GetMouseButtonDown(0) && Time.timeScale != 0 && health && health.currentHp > 0){
+            FrisbieController frisbie = ObjectPooler.instance.SpawnFromPool("Disk", new Vector3(shootPos.position.x, .3f, shootPos.position.z), transform.rotation).GetComponent<FrisbieController>();
+            //FrisbieController frisbie = Instantiate(disk, transform.position, transform.rotation).GetComponent<FrisbieController>();
+            if(AudioManager.instance!=null)
+                AudioManager.instance.PlayOneShot("laser" + Random.Range(1, 6));
+            shootParticles.Play();
+            switch (weaponSelected){
+                case 1:
+                    frisbie.frisbieType = FrisbieController.FrisbieType.Default;
+                    frisbie.AddForce(movementInput * speed);
+                    break;
+                case 2:
+                    frisbie.frisbieType = FrisbieController.FrisbieType.Boomerang;
+                    frisbie.AddForce(movementInput * speed);
+                    break;
+                case 3:
+                    frisbie.frisbieType = FrisbieController.FrisbieType.Explosive;
+                    frisbie.AddForce(movementInput * speed);
+                    break;
+            }
+            health.RemoveDisk();
+            if (health.currentHp == 0){
+                AudioManager.instance.Pause("InGameMusic");
+                AudioManager.instance.Play("clock2-loop");
+                deathScreenAnim.SetTrigger("Die");
+            }
+            if (ScreenShakeCall.instance!=null)
+                ScreenShakeCall.instance.ShakeCamera(.5f, .25f);
+        }
+
+        if (dead){
+            cmTrack.m_PathPosition += Time.unscaledDeltaTime * camRotationSpeed;
+        }else{
+            timeSurvived += Time.deltaTime;
+        }
+    }
+
+    void FixedUpdate(){
+        Vector3 movementInput = new Vector3(Input.GetAxisRaw("Horizontal"), 0, Input.GetAxisRaw("Vertical")).normalized;
+        anim.SetFloat("Speed", movementInput.magnitude);
+        if (movementInput.magnitude >= .1f && !Input.GetMouseButtonDown(0)){
+            float targetAngle = Mathf.Atan2(movementInput.x, movementInput.z) * Mathf.Rad2Deg + mainCamera.transform.eulerAngles.y;
+            float angle = Mathf.SmoothDampAngle(transform.eulerAngles.y, targetAngle, ref rotationVelocity, .1f);
+            transform.rotation = Quaternion.Euler(0, angle, 0);
+
+            Vector3 moveDirection = Quaternion.Euler(0, targetAngle, 0) * Vector3.forward;
+            //rb.MovePosition(rb.position + moveDirection.normalized * speed * Time.deltaTime);
+            rb.velocity = moveDirection.normalized * speed;
+
+            currentStepTime -= Time.deltaTime;
+            if(currentStepTime <= 0 && AudioManager.instance!=null){
+                stepParticle.Play();
+                if (step){
+                    AudioManager.instance.PlayOneShot("paso1");
+                    step = false;
+                }else{
+                    AudioManager.instance.PlayOneShot("paso2");
+                    step = true;
+                }
+                currentStepTime = timeBetweenSteps;
+            }
+        }else{
+            rb.velocity = Vector3.zero;
+        }
+
+        if(movementInput.magnitude >= .1f && !Input.GetMouseButtonDown(0) && !walking){
+            currentStepTime = 0;
+            walking = true;
+        }else if(movementInput.magnitude < .1f && !Input.GetMouseButtonDown(0)){
+            walking = false;
+        }
+    }
+
+    void LateUpdate(){
+        Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);
+        RaycastHit hit;
+
+        if (Physics.Raycast(ray, out hit, 1000f, whatIsGround) && Time.timeScale != 0){
+            aimPos.position = new Vector3(hit.point.x, aimPos.position.y, hit.point.z);
+        }
+
+        Vector3 targetVector = transform.position - mainCamera.transform.position;
+        getDiskIcon.transform.rotation = Quaternion.LookRotation(targetVector, mainCamera.transform.rotation * Vector3.up);
+    }
+
+    void damageSheen()
+    {
+        Debug.Log("sheeen");
+        foreach (SkinnedMeshRenderer mr in GetComponentsInChildren<SkinnedMeshRenderer>())
+            mr.material.SetColor("EmissiveCol", Color.white);
+        Invoke(nameof(revertDamageSheen), .1f);
+    }
+    void revertDamageSheen()
+    {
+        foreach (SkinnedMeshRenderer mr in GetComponentsInChildren<SkinnedMeshRenderer>())
+            mr.material.SetColor("EmissiveCol", Color.black);
+    }
+
+    public void Damage(int amt){
+        if (invencible)
+            return;
+
+        float randomSound = Random.Range(0, 300);
+        if(randomSound < 100){
+            AudioManager.instance.PlayOneShot("grito2");
+        }else if(randomSound >= 100 && randomSound < 200){
+            AudioManager.instance.PlayOneShot("grito5");
+        }else{
+            AudioManager.instance.PlayOneShot("grito11");
+        }
+
+        if (health.currentHp == 0){
+            Die();
+            return;
+        }
+
+        for (int i = 0; i < amt; i++){
+            damageSheen();
+            if (health != null){
+                health.RemoveDisk();
+                damageEv.Invoke();
+            }
+        }
+        
+        if (health.currentHp == 0){
+            AudioManager.instance.Pause("InGameMusic");
+            AudioManager.instance.Play("clock2-loop");
+            deathScreenAnim.SetTrigger("Die");
+        }
+
+        if (ScreenShakeCall.instance!=null)
+            ScreenShakeCall.instance.ShakeCamera(1, .5f);
+    }
+
+    void OnTriggerEnter(Collider col){
+        if (col.CompareTag("Disk") || col.CompareTag("DiskPickup")){
+            if (health.currentHp == 0){
+                AudioManager.instance.UnPause("InGameMusic");
+                StartCoroutine(AudioManager.instance.FadeOut("clock2-loop", .5f));
+                deathScreenAnim.SetTrigger("GetDisk");
+
+                getDiskIcon.SetTrigger("GetDisk");
+                health.AddDisk();
+                col.transform.parent.gameObject.SetActive(false);
+            }else{
+                if (health.AddDisk()){
+                    getDiskIcon.SetTrigger("GetDisk");
+                    AudioManager.instance.PlayOneShot("recogerdisco2");
+                    col.transform.parent.gameObject.SetActive(false);
+                }
+            }
+        }
+    }
+
+    public void Die(){
+        GameMaster.Instance.ResetLevel();
+        track.position = new Vector3(transform.position.x, 0, transform.position.z);
+        trackedCam.gameObject.SetActive(true);
+        cmTrack = trackedCam.GetCinemachineComponent<CinemachineTrackedDolly>();
+        dead = true;
+        Time.timeScale = 0;
+        deathScreenAnim.updateMode = AnimatorUpdateMode.UnscaledTime;
+        AudioManager.instance.StopAll();
+        PlayerPrefs.DeleteKey("HP");
+    }
+
+    public void Win(){
+        GameMaster.Instance.ResetLevel();
+        winScreenAnim.SetTrigger("Win");
+        dead = true;
+        PlayerPrefs.DeleteKey("HP");
+        StartCoroutine(WinPause());
+    }
+
+    IEnumerator WinPause(){
+        yield return new WaitForSeconds(1f);
+        StartCoroutine(AudioManager.instance.FadeIn("MainPiano", 1));
+        FindObjectOfType<PauseMenu>().enabled = false;
+        winScreenAnim.updateMode = AnimatorUpdateMode.UnscaledTime;
+        Time.timeScale = 0;
+    }
+}

Assets/Scripts/Player/PlayerController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 020038eeca8cf7b4d91eef999c143bea
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Player/PlayerDeath.cs

@@ -0,0 +1,12 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class PlayerDeath : MonoBehaviour{
+
+    [SerializeField] PlayerController player = default;
+
+    public void Die(){
+        player.Die();
+    }
+}

Assets/Scripts/Player/PlayerDeath.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 44a107ce4b40c054fb5e490134ebc1a2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Player/PlayerHealth.cs

@@ -0,0 +1,60 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class PlayerHealth : MonoBehaviour{
+
+    [SerializeField] GameObject disk = default;
+    [SerializeField, Min(0)] int startHp = 10;
+    [SerializeField] RectTransform healthStartPos = default;
+    public int currentHp;
+    [SerializeField, Range(0, 100)] float distanceBetweenDisks = 30f;
+    Vector3 nextDiskPos;
+
+    List<Animator> diskAnimators = new List<Animator>();
+
+    [Space]
+    [SerializeField, Min(0)] int maxHp = 15;
+    [SerializeField] bool hasMaxHp = false;
+
+    // Start is called before the first frame update
+    void Start(){
+        currentHp = PlayerPrefs.GetInt("HP", startHp);
+        if (currentHp == 0)
+            currentHp = startHp;
+
+        for (int i = 0; i < currentHp; i++){
+            GameObject newDisk = Instantiate(disk, Vector3.zero, Quaternion.identity, transform);
+            newDisk.GetComponent<RectTransform>().anchoredPosition3D = healthStartPos.anchoredPosition3D + Vector3.right * distanceBetweenDisks * i;
+            diskAnimators.Add(newDisk.GetComponent<Animator>());
+            nextDiskPos = Vector3.right * distanceBetweenDisks * (i + 1);
+        }
+    }
+
+    public bool AddDisk(){
+        if (hasMaxHp && currentHp >= maxHp)
+            return false;
+
+        foreach(Animator a in diskAnimators){
+            a.SetTrigger("RestartAnimation");
+        }
+        GameObject newDisk = Instantiate(disk, Vector3.zero, Quaternion.identity, transform);
+        newDisk.GetComponent<RectTransform>().anchoredPosition3D = healthStartPos.anchoredPosition3D + nextDiskPos;
+        diskAnimators.Add(newDisk.GetComponent<Animator>());
+        nextDiskPos += Vector3.right * distanceBetweenDisks;
+        currentHp++;
+        PlayerPrefs.SetInt("HP", currentHp);
+        return true;
+    }
+
+    public void RemoveDisk(){
+        if(currentHp > 0){
+            Animator anim = diskAnimators[diskAnimators.Count - 1];
+            diskAnimators.Remove(anim);
+            Destroy(anim.gameObject);
+            nextDiskPos -= Vector3.right * distanceBetweenDisks;
+            currentHp--;
+            PlayerPrefs.SetInt("HP", currentHp);
+        }
+    }
+}

Assets/Scripts/Player/PlayerHealth.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ed9fc316b730d0f4d82e0963ce7fdf37
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Player/ProjectileCollisionChecker.cs

@@ -0,0 +1,33 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ProjectileCollisionChecker : MonoBehaviour
+{
+    public float colliderScalar = .75f;
+    void Update()
+    {
+        Collider[] colliders = Physics.OverlapBox(transform.position,transform.parent.localScale*colliderScalar, transform.rotation);
+
+        ExtDebug.DrawBox(transform.position, transform.parent.localScale * colliderScalar, transform.rotation, Color.red);
+
+        foreach (Collider c in colliders)
+        {
+            if (c.GetComponent<BulletMovement>() != null)
+            {
+                c.GetComponent<BulletMovement>().bulletHit();
+                GetComponent<PlayerController>().Damage(1);
+                Debug.Log("Player hit");
+                if (GameMaster.Instance.Pooler != null)
+                    c.gameObject.SetActive(false);
+                else
+                    Destroy(c.gameObject);
+            }
+        }
+    }
+    //void OnDrawGizmos()
+    //{
+    //    Gizmos.color = Color.red;
+    //    Gizmos.DrawWireCube(transform.position, transform.parent.localScale * colliderScalar);
+    //}
+}

Assets/Scripts/Player/ProjectileCollisionChecker.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 726d113c7c974e044bfa3ecf20c84d0e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Player/UpdateShader.cs

@@ -0,0 +1,12 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class UpdateShader : MonoBehaviour
+{
+
+    void Update()
+    {
+        Shader.SetGlobalVector("Player_position", transform.position);
+    }
+}

Assets/Scripts/Player/UpdateShader.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a48a9903a54c2d143b1a0b315a0422bd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Player/WeaponSelectedUI.cs

@@ -0,0 +1,72 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class WeaponSelectedUI : MonoBehaviour{
+
+    int currentSelected = 0;
+    [SerializeField] Transform rollPivot = default;
+    float currentRot;
+    float rotationVelocity;
+    PlayerController player;
+
+    // Start is called before the first frame update
+    void Awake(){
+        currentRot = rollPivot.eulerAngles.z;
+        player = GameMaster.Instance.player.GetComponent<PlayerController>();
+    }
+
+    // Update is called once per frame
+    void Update(){
+        currentRot = 90 * currentSelected;
+        //currentRot += 90 * Mathf.Clamp(Input.mouseScrollDelta.y, -1, 1);
+        if(Mathf.Clamp(Input.mouseScrollDelta.y, -1, 1) == 1){
+            switch (currentSelected){
+                case 0:
+                    Debug.Log("Boomerang");
+                    player.weaponSelected = 2;
+                    currentSelected = 1;
+                    break;
+                case 1:
+                    Debug.Log("Default");
+                    player.weaponSelected = 1;
+                    currentSelected = 2;
+                    break;
+                case 2:
+                    Debug.Log("Explosive");
+                    currentSelected = 3;
+                    player.weaponSelected = 3;
+                    break;
+                case 3:
+                    Debug.Log("Default");
+                    currentSelected = 0;
+                    player.weaponSelected = 1;
+                    break;
+            }
+        }else if(Mathf.Clamp(Input.mouseScrollDelta.y, -1, 1) == -1){
+            switch (currentSelected){
+                case 0:
+                    Debug.Log("Explosive");
+                    currentSelected = 3;
+                    player.weaponSelected = 3;
+                    break;
+                case 1:
+                    Debug.Log("Default");
+                    player.weaponSelected = 1;
+                    currentSelected = 0;
+                    break;
+                case 2:
+                    Debug.Log("Boomerang");
+                    player.weaponSelected = 2;
+                    currentSelected = 1;
+                    break;
+                case 3:
+                    Debug.Log("Default");
+                    player.weaponSelected = 1;
+                    currentSelected = 2;
+                    break;
+            }
+        }
+        rollPivot.rotation = Quaternion.Euler(0, 0, Mathf.SmoothDampAngle(rollPivot.eulerAngles.z, currentRot, ref rotationVelocity, .1f));
+    }
+}

Assets/Scripts/Player/WeaponSelectedUI.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3e38a246731b05049bd43684d414013f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: