init

Assets/Scripts/SwordsGame/SwordAttack.cs

@@ -0,0 +1,58 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class SwordAttack : MonoBehaviour{
+    [SerializeField] GameTutorialControler tutorial;
+    [SerializeField] float attackDamage = 20f;
+    Animator anim;
+
+    [Space]
+    [SerializeField] Transform attackPos = default;
+    [SerializeField, Range(0, 3)] float attackRange = 2;
+    [SerializeField] LayerMask whatIsEnemy = -1;
+
+    SwordPlayerController player;
+    bool attacking;
+
+    // Start is called before the first frame update
+    void Awake(){
+        anim = GetComponent<Animator>();
+        player = FindObjectOfType<SwordPlayerController>();
+    }
+
+    // Update is called once per frame
+    void Update(){
+        if (Input.GetMouseButtonDown(0) && !attacking && tutorial.gameStarted)
+        {
+            anim.SetTrigger("Attack");
+            attacking = true;
+            player.StopMovement();
+        }
+    }
+
+    public void Attack(){
+        Collider[] hitEnemies = Physics.OverlapSphere(attackPos.position, attackRange, whatIsEnemy);
+
+        if(hitEnemies.Length == 0)
+            AudioManager.instance.PlayOneShot("SFX_falloEspada" + Random.Range(1, 5), true);
+        else
+            AudioManager.instance.PlayOneShot("SFX_Espada" + Random.Range(1, 3), true);
+
+        foreach (Collider enemy in hitEnemies){
+            enemy.GetComponent<SwordsEnemyController>().Damage(attackDamage);
+        }
+    }
+
+    public void EndAttack(){
+        attacking = false;
+        player.RegainMovement();
+    }
+
+    void OnDrawGizmos(){
+        if (attackPos == null)
+            return;
+
+        Gizmos.DrawWireSphere(attackPos.position, attackRange);
+    }
+}

Assets/Scripts/SwordsGame/SwordAttack.cs.meta

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

Assets/Scripts/SwordsGame/SwordCharacterType.cs

@@ -0,0 +1,10 @@
+[System.Serializable]
+public class SwordCharacterType{
+
+    public float speed;
+
+    public float detectArea;
+
+    public float angryIncreaseTime;
+    public float healthAlert;
+}

Assets/Scripts/SwordsGame/SwordCharacterType.cs.meta

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

Assets/Scripts/SwordsGame/SwordEnemyAttack.cs

@@ -0,0 +1,64 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.AI;
+
+public class SwordEnemyAttack : MonoBehaviour{
+
+    [SerializeField] Animator anim = default;
+    [SerializeField] float attackDamage = 20f;
+    [SerializeField, Range(0, .5f)] float attackMaxDelay = .1f;
+    bool attacking;
+
+    [SerializeField] NavMeshAgent agent;
+
+    [Space]
+    [SerializeField] Transform attackPos = default;
+    [SerializeField, Range(0, 3)] float attackRange = 2;
+    [SerializeField] LayerMask whatIsEnemy = -1;
+
+    // Start is called before the first frame update
+    void Update(){
+        Collider[] hitEnemies = Physics.OverlapSphere(attackPos.position, attackRange, whatIsEnemy);
+        if (hitEnemies.Length > 0 && !attacking)
+        {
+            if (GetComponentInParent<SwordsEnemyController>().hp > 0f) {
+                attacking = true;
+                anim.SetTrigger("Attack");
+            }
+        }
+
+        if (attacking)
+        {
+            agent.isStopped = true;
+        }
+        else
+        {
+            agent.isStopped = false;
+        }
+    }
+
+    public void Attack(){
+        Collider[] hitEnemies = Physics.OverlapSphere(attackPos.position, attackRange, whatIsEnemy);
+
+        if (hitEnemies.Length == 0)
+            AudioManager.instance.PlayOneShot("SFX_falloEspada" + Random.Range(1, 5));
+        else
+            AudioManager.instance.PlayOneShot("SFX_Espada" + Random.Range(1, 3));
+
+        foreach (Collider enemy in hitEnemies){
+            enemy.GetComponent<SwordPlayerController>().Damage(attackDamage);
+        }
+    }
+
+    public void EndAttack(){
+        attacking = false;
+    }
+
+    void OnDrawGizmos(){
+        if (attackPos == null)
+            return;
+
+        Gizmos.DrawWireSphere(attackPos.position, attackRange);
+    }
+}

Assets/Scripts/SwordsGame/SwordEnemyAttack.cs.meta

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

Assets/Scripts/SwordsGame/SwordPlayerController.cs

@@ -0,0 +1,218 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class SwordPlayerController : MonoBehaviour
+{
+    [SerializeField] ScenesTransitionController scenesTransition = default;
+    [SerializeField] GameTutorialControler tutorial = default;
+    [SerializeField] Animator anim = default;
+    [SerializeField] public Animator charAnim = default;
+    [SerializeField] CharacterController controller = default;
+    [SerializeField] Transform cam = default;
+    [SerializeField] Transform enemy = default;
+
+    [SerializeField] float speed = 6;
+
+    [SerializeField, Range(0, .3f)] float turnSmoothTime = .1f;
+    float turnSmoothVelocity;
+
+    [Header("Jump")]
+    [SerializeField, Min(0)] float gravity = 15f;
+    [SerializeField] float jumpHeight = 3f;
+    [SerializeField, Range(0, .5f)] float jumpDelay = .5f;
+    Vector3 velocity;
+
+    [SerializeField] Transform groundCheck = default;
+    [SerializeField, Range(0, .5f)] float groundDistance = .4f;
+    [SerializeField] LayerMask groundMask = -1;
+    bool isGrounded;
+
+    [Space]
+    [SerializeField] Image healthBar = default;
+    [SerializeField] float maxHp = 100;
+    float hp;
+    bool canMove;
+
+    [Space]
+    [SerializeField] GameObject playerHPbar;
+    [SerializeField] GameObject enemyHPbar;
+    [SerializeField] GameObject playerHPbarLabel;
+    [SerializeField] GameObject enemyHPbarLabel;
+
+    [SerializeField, Range(0, 1f)] float stepsInterval = .5f;
+    float currentTime;
+
+    bool scoreDistributed;
+
+    void Awake(){
+        Cursor.lockState = CursorLockMode.Locked;
+        hp = maxHp;
+        canMove = true;
+
+        charAnim = GetComponent<CharacterIdController>().SetPlayerCustom();
+    }
+
+    float currentX;
+    float xDirVelocity;
+    float currentY;
+
+    // Update is called once per frame
+    void Update(){
+        if (tutorial.gameStarted)
+        {
+            isGrounded = Physics.CheckSphere(groundCheck.position, groundDistance, groundMask);
+
+            if (isGrounded && velocity.y < 0)
+            {
+                velocity.y = -2f;
+            }
+
+            float horizontal = Input.GetAxisRaw("Horizontal");
+            float vertical = Input.GetAxisRaw("Vertical");
+            Vector3 direction = new Vector3(horizontal, 0, vertical).normalized;
+
+            if (direction.magnitude >= .1f && canMove)
+            {
+                float targetAngle = Mathf.Atan2(direction.x, direction.z) * Mathf.Rad2Deg + cam.eulerAngles.y;
+                float angle = Mathf.SmoothDampAngle(transform.eulerAngles.y, targetAngle, ref turnSmoothVelocity, turnSmoothTime);
+                transform.rotation = Quaternion.Euler(0, angle, 0);
+
+                Vector3 moveDir = Quaternion.Euler(0f, targetAngle, 0f) * Vector3.forward;
+                controller.Move(moveDir.normalized * speed * Time.deltaTime);
+
+                Vector3 directionX = direction.x * transform.forward;
+                Vector3 directionZ = direction.z * transform.forward;
+                currentX = Mathf.SmoothDamp(currentX, directionX.x, ref xDirVelocity, .1f);
+                currentY = Mathf.SmoothDamp(currentY, directionZ.z, ref xDirVelocity, .1f);
+                charAnim.SetFloat("VelocityY", 1);
+                anim.SetBool("Moving", true);
+
+                currentTime += Time.deltaTime;
+                if (currentTime >= stepsInterval)
+                {
+                    AudioManager.instance.PlayOneShot("SFX_paso" + Random.Range(1, 6), true);
+                    currentTime = 0;
+                }
+            }
+            else
+            {
+                currentX = Mathf.SmoothDamp(currentX, 0, ref xDirVelocity, .1f);
+                currentY = Mathf.SmoothDamp(currentY, 0, ref xDirVelocity, .1f);
+                charAnim.SetFloat("VelocityY", 0);
+                anim.SetBool("Moving", false);
+            }
+
+            velocity.y -= gravity * Time.deltaTime;
+            controller.Move(velocity * Time.deltaTime);
+        }
+    }
+
+    public void StopMovement(){
+        transform.LookAt(new Vector3(enemy.position.x, transform.position.y, enemy.position.z));
+        canMove = false;
+    }
+
+    public void RegainMovement(){
+        if(hp > 0){
+            canMove = true;
+        }
+    }
+
+    public void Damage(float ammount){
+        if(hp > 0){
+            hp -= ammount;
+            healthBar.transform.localScale = new Vector3(Mathf.Clamp(hp / maxHp, 0, 1), 1, 1);
+
+            ScreenShakeCall.instance.ShakeCamera(12.5f, .4f);
+
+            if (hp > 0f){
+                charAnim.SetTrigger("Damage");
+                float randomAnim = Random.Range(0, 200);
+                if(randomAnim > 100){
+                    GameObject pow = ObjectPooler.instance.SpawnFromPool("Pow", transform.position + Vector3.up);
+                    pow.transform.LookAt(cam);
+                }
+                else{
+                    GameObject pam = ObjectPooler.instance.SpawnFromPool("Pam", transform.position + Vector3.up);
+                    pam.transform.LookAt(cam);
+                }
+            }else{
+                GameObject kapow = ObjectPooler.instance.SpawnFromPool("Kapow", transform.position);
+                kapow.transform.LookAt(Camera.main.transform);
+                charAnim.SetTrigger("Die");
+                StopMovement();
+                ReturnToMenu(GameObject.Find("Enemy").GetComponent<CharacterIdController>().CharacterId, gameObject.GetComponent<CharacterIdController>().CharacterId);
+                
+            }
+        }
+    }
+
+    void OnDrawGizmos(){
+        if(groundCheck != null){
+            Gizmos.color = Color.red;
+            Gizmos.DrawWireSphere(groundCheck.position, groundDistance);
+        }
+    }
+
+    public void ShowLives()
+    {
+        playerHPbar.SetActive(true);
+        enemyHPbar.SetActive(true);
+        playerHPbarLabel.SetActive(true);
+        enemyHPbarLabel.SetActive(true);
+
+        StartCoroutine(AudioManager.instance.FadeOut("transicion", 1));
+        StartCoroutine(AudioManager.instance.FadeIn("04_espadas", 1));
+    }
+
+    void ReturnToMenu(int winner, int looser)
+    {
+        if (!scoreDistributed)
+        {
+            //AudioManager.instance.PlayOneShot("SFX_booring");
+
+            StartCoroutine(BetweenScenePass.instance.DistributeScore(
+                BetweenScenePass.Games.Swords,
+                winner,
+                null));
+
+            int newWinner1 = winner;
+            int i = 0;
+            while (i < 100)
+            {
+                newWinner1 = Random.Range(0, 6);
+                i++;
+                if (newWinner1 != winner && newWinner1 != looser)
+                {
+                    break;
+                }
+            }
+
+            StartCoroutine(BetweenScenePass.instance.DistributeScore(
+                BetweenScenePass.Games.Swords,
+                newWinner1,
+                null));
+
+            int newWinner2;
+            newWinner2 = winner;
+            i = 0;
+            while (i < 100)
+            {
+                newWinner2 = Random.Range(0, 6);
+                i++;
+                if (newWinner2 != winner && newWinner2 != looser && newWinner2 != newWinner1)
+                {
+                    break;
+                }
+            }
+
+            StartCoroutine(BetweenScenePass.instance.DistributeScore(
+                BetweenScenePass.Games.Swords,
+                newWinner2,
+                scenesTransition));
+            scoreDistributed = true;
+        }
+    }
+}

Assets/Scripts/SwordsGame/SwordPlayerController.cs.meta

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

Assets/Scripts/SwordsGame/SwordsEnemyController.cs

@@ -0,0 +1,175 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.AI;
+using UnityEngine.UI;
+
+public class SwordsEnemyController : MonoBehaviour
+{
+    [SerializeField] ScenesTransitionController scenesTransition = default;
+    [SerializeField] GameTutorialControler tutorial = default;
+    [SerializeField] Transform player = default;
+    NavMeshAgent agent;
+    [SerializeField] Animator charAnim = default;
+
+    [System.Serializable] public enum Personality {Shy, Hyperactive, Balanced}
+    [Space]
+    public Personality personality;
+
+    [SerializeField] float maxHp = 100;
+    public float hp;
+
+    [SerializeField] float currentRadius = 10;
+    [SerializeField, Range(0, 3)] float angryLevel;
+    float angryLevelIncreaseTime;
+    [SerializeField] float healthAlert;
+
+    [Space]
+    [SerializeField] SwordCharacterType shyStats = default;
+    [SerializeField] SwordCharacterType angryStats = default;
+    [SerializeField] SwordCharacterType balancedStats = default;
+
+    [Space]
+    [SerializeField] Image healthBar = default;
+
+    [SerializeField, Range(0, 1f)] float stepsInterval = .5f;
+    float currentTime;
+
+    bool scoreDistributed;
+
+    // Start is called before the first frame update
+    void Awake(){
+
+        charAnim = charAnim = GetComponent<CharacterIdController>().SetRandomNpcCustom();
+
+
+        agent = GetComponent<NavMeshAgent>();
+        switch (personality){
+            case Personality.Balanced:
+                currentRadius = balancedStats.detectArea;
+                healthAlert = balancedStats.healthAlert;
+                angryLevelIncreaseTime = balancedStats.angryIncreaseTime;
+                agent.speed = balancedStats.speed;
+                break;
+            case Personality.Hyperactive:
+                currentRadius = angryStats.detectArea;
+                healthAlert = angryStats.healthAlert;
+                angryLevelIncreaseTime = angryStats.angryIncreaseTime;
+                agent.speed = angryStats.speed;
+                break;
+            case Personality.Shy:
+                currentRadius = shyStats.detectArea;
+                healthAlert = shyStats.healthAlert;
+                angryLevelIncreaseTime = shyStats.angryIncreaseTime;
+                agent.speed = shyStats.speed;
+                break;
+        }
+
+        hp = maxHp;
+    }
+
+    // Update is called once per frame
+    void Update(){
+        if (tutorial.gameStarted)
+        {
+            agent.SetDestination(new Vector3(player.position.x, 0, player.position.z));
+
+            if ((player.position - transform.position).sqrMagnitude < agent.stoppingDistance * agent.stoppingDistance)
+            {
+                transform.LookAt(new Vector3(player.position.x, transform.position.y, player.position.z));
+            }
+
+            charAnim.SetFloat("VelocityY", 1);
+
+            currentTime += Time.deltaTime;
+            if (currentTime >= stepsInterval)
+            {
+                AudioManager.instance.PlayOneShot("SFX_paso" + Random.Range(1, 6), true);
+                currentTime = 0;
+            }
+
+            angryLevel += angryLevelIncreaseTime * Time.deltaTime;
+            angryLevel = Mathf.Clamp(angryLevel, 0, 3);
+        }
+    }
+
+    public void Damage(float amount){
+        if (hp > 0){
+            hp -= amount;
+            healthBar.transform.localScale = new Vector3(Mathf.Clamp(hp / maxHp, 0, 1), 1, 1);
+
+            ScreenShakeCall.instance.ShakeCamera(12.5f, .4f);
+
+            if (hp > 0f){
+                float randomAnim = Random.Range(0, 200);
+                if (randomAnim > 100){
+                    GameObject pow = ObjectPooler.instance.SpawnFromPool("Pow", transform.position + Vector3.up);
+                    pow.transform.LookAt(Camera.main.transform);
+                }else{
+                    GameObject pam = ObjectPooler.instance.SpawnFromPool("Pam", transform.position + Vector3.up);
+                    pam.transform.LookAt(Camera.main.transform);
+                }
+                charAnim.SetTrigger("Damage");
+            }else{
+                GameObject kapow = ObjectPooler.instance.SpawnFromPool("Kapow", transform.position);
+                kapow.transform.LookAt(Camera.main.transform);
+                charAnim.SetTrigger("Die");
+                ReturnToMenu(GameObject.Find("Player").GetComponent<CharacterIdController>().CharacterId, gameObject.GetComponent<CharacterIdController>().CharacterId);
+            }
+        }
+    }
+
+    void OnDrawGizmosSelected(){
+        Gizmos.DrawWireSphere(transform.position, currentRadius);
+    }
+
+    void ReturnToMenu(int winner, int looser)
+    {
+        if (!scoreDistributed)
+        {
+            AudioManager.instance.PlayOneShot("SFX_campanillas");
+
+            StartCoroutine(BetweenScenePass.instance.DistributeScore(
+                BetweenScenePass.Games.Swords,
+                winner,
+                null));
+
+            int newWinner1 = winner;
+            int i = 0;
+            while (i < 100)
+            {
+                newWinner1 = Random.Range(0, 6);
+                i++;
+                if (newWinner1 != winner && newWinner1 != looser)
+                {
+                    break;
+                }
+            }
+
+            StartCoroutine(BetweenScenePass.instance.DistributeScore(
+                BetweenScenePass.Games.Swords,
+                newWinner1,
+                null));
+
+            int newWinner2;
+            newWinner2 = winner;
+            i = 0;
+            while (i < 100)
+            {
+                newWinner2 = Random.Range(0, 6);
+                i++;
+                if (newWinner2 != winner && newWinner2 != looser && newWinner2 != newWinner1)
+                {
+                    break;
+                }
+            }
+
+            StartCoroutine(BetweenScenePass.instance.DistributeScore(
+                BetweenScenePass.Games.Swords,
+                newWinner2,
+                scenesTransition));
+            scoreDistributed = true;
+        }
+    }
+
+}

Assets/Scripts/SwordsGame/SwordsEnemyController.cs.meta

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