Usando los PowerUps

Un powerup que se me ocurre es el de la propia invulnerabilidad por unos segundos.

Mi implementación de la vulnerabilidad es crear una clase Invulnerabilidad que se encargue de contar el tiempo para que se acabe la invulnerabilidad:

Y luego configurarlo en un evento que creé llamado onReceiveDamage. Cuando reciba daño, el jguador se volverá invulnerable por 5 segundos como está configurado en la figura de arriba. El componente Damageable tiene una referencia al componente Invulnerability y antes de que reciba daño, primero verificará si es que el objeto es vulnerable.

Algo adicional que hice para el PowerUp de “PowerShot” es que éste solo dure 3 segundos y luego de ésos 3 segundos los disparos vuelvan a la normalidad:

En el switch del tipo de PowerUp iría así:

case PowerUp.PowerUpType.PowerShot: // Poder de disparo
                    powerShotEnabled = true;
                    StartCoroutine(PowerShotTime()); // Llamamos a la corutina de duración temporal de powerup powershot
                    break;

Y la corutina simplemente esperaría 3 segundos antes de volver a desactivar el powershot:

    // Corutina de duración temporal del powerUp powershot
    IEnumerator PowerShotTime(){
        yield return new WaitForSeconds(powerShotTime); // Tiempo de espera de x segundos (segundos en la variable powerUpTime)
        powerShotEnabled = false;
    }

Lo que hice para la invulnerabilidad fue crear una variable publica Invulneravility inicializada en falso, la que vuelvo true cuando el enemigo colisiona con el player y la uso para hacer daño solo si es false luego una corrutina para volverla false si ya esta en true acá la imagen del código del player y del enemy

Un PowerUp que simule una escopeta (3 balas a la vez pero una menor distancia o tiempo de vida de las balas).

POWERUP SANADOR!

Mi solución

bool hasCooldown = false;
private void OnTriggerEnter2D(Collider2D collision)
    {
        if(!hasCooldown)
        {
            if (collision.CompareTag("Enemy"))
            {
                healthP--;
                hasCooldown = true;
                StartCoroutine(Cooldown());
                if (healthP <= 0)
                {
                    Destroy(gameObject);
                }
            }
        }

        if (collision.CompareTag("PowerUp"))
        {
            switch (collision.GetComponent<PowerUp>().powerUpType)
            {
                case PowerUp.PowerUpType.FireRateIncrease:
                    fireRate++;
                    break;
                case PowerUp.PowerUpType.PowerShot:
                    powerShotEnable = true;
                    break;
            }
            Destroy(collision.gameObject, 0.1f);
        }
    }
    IEnumerator Cooldown()
    {
        yield return new WaitForSeconds(3f);
        hasCooldown = false;

        StopCoroutine(Cooldown());
    }

Mi solucion:

En el enemigo tengo el llamado de la funcion TakeDamage() del player:

    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.CompareTag("Player"))
        {
            collision.GetComponent<Player>().TakeDamage();
        }
    }

Y en el player le hice un cambio a la funcion TakeDamage():

bool takeDamageCooldown = true;

    public void TakeDamage()
    {
        if (takeDamageCooldown)
            playerHealth--;
        takeDamageCooldown = false;
        StartCoroutine(TakeDamageCooldown());

        if (playerHealth <= 0)
        {
            //GameOver
        }
    }

    IEnumerator TakeDamageCooldown()
    {
        yield return new WaitForSeconds(3f);
        takeDamageCooldown = true;
    }

Genial

Mi solución al reto

En el script Player.cs, cree una variable booleana de invulnerabilidad (invulnerability) que comienza en false, luego en la función “TakeDamage” activo esa variable (true) después de recibir daño del enemigo, y seguido comienzo una cortina que llama a una “rutina” (invulnerabilityDelay) que va a esperar esos 3 segundos y después de ese tiempo vuelve a asignarle el valor false a la variable de invulnerabilidad.

Player.cs

//...

public class Player : MonoBehaviour
{
    // Variable de invulnerabilidad
    bool invulnerability = false;

    // Tiempo de invulnerabilidad
    float invulnerabilityTime = 3f;

    //...

    // Función de daño del enemigo
    public void TakeDamage()
    {
        // Invulnerabilidad del Player al recibir daño.
        if (!invulnerability)
        {
            health -= 1;
            invulnerability = true;
            StartCoroutine(invulnerabilityDelay());
        }

        // Destrucción del objeto player si la vida llega a 0.
        if (health <= 0)
        {
            Destroy(gameObject);
        }
    }

    // Rutina de invulnerabilidad
    IEnumerator invulnerabilityDelay()
    {
        yield return new WaitForSeconds(invulnerabilityTime);
        invulnerability = false;
    }

    //...
}

Un Powerup que haga al Player disparar mas balas

se aprende mucho con este curso

Lo que yo hice fue:

1. Cree dos variables en el script de player una de tipo int que sería el tiempo de duración de la invulnerabilidad, llamada invulnerabilityTime, y otra de tipo booleano, llamada invulnerability, (que por default estaría en false) para determinar si el personaje es invulnerable o no:
   

   

2. En el método TakeDamage() que creamos en clases anteriores, en el que el personaje recibía daño, puse como condición que la variable booleana invulnerability debía estar en false para que se ejecutara el mecanismo de reducir la vida del personaje:
   

   

3. Por ultimo, agregue un caso nuevo la sección de las colisiones del personaje con los power ups (Obviamente para lograr esto, previamente aumente el array de power ups existentes en el script PowerUp, y agregué uno llamado Invulnerability). En este nuevo caso especifiqué que el booleano invulnerability cambiara su valor a true, evitando que el personaje pierda vida al colisionar con enemigos (ya que como mencione anteriormente !invulnerability era una condicion para perder vida), y además agregue una corrutina que se encargará de esperar unos segundos determinados por la variable invulnerabilityTime (para no tener numeros mágicos) y despues de este tiempo regresaria a la variable booleana invulnerability a su estado default que es false:
   

   

Un power up que se me ocurre es paralizar a los enemigos y también desactivarles el daño en lo que dura el efecto.

Destroy tiene la opción de retrasar un poco el efecto, de forma que se sienta un tanto natural.