コード例 #1
0
    public void MagiaSeleccionada(AtaqueBase ataqueMagico)
    {
        enDescripcion = true;
        seleccionable = false;

        //Mostrar panel de descripcion del objetos
        panelDescpMagias.SetActive(true);
        panelDescpMagias.transform.Find("Magia").gameObject.SetActive(true);
        panelDescpMagias.transform.Find("Magia").GetComponent <RellenarMagias>().Rellenar(ataqueMagico);
    }
コード例 #2
0
    //Seleccionar Objetivo -> Magia
    public void SeleccionarObjetivo(AtaqueBase magia)
    {
        List <GameObject> enemigosInstanciados = RellenarListaEnemigos(sistemaTurnos.enemigosCombate);

        menuLista.GetComponent <SistemaSeleccion>().menuAnterior = HeroeStateMachine.HeroeInputMenu.MAGIA;
        menuLista.GetComponent <SistemaSeleccion>().HSM          = HSM;
        menuLista.GetComponent <SistemaSeleccion>().sistemaMenus = this;
        menuLista.GetComponent <SistemaSeleccion>().magia        = magia;
        menuLista.GetComponent <SistemaSeleccion>().Inicializar(enemigosInstanciados, "enemigos");
    }
コード例 #3
0
    public void MagiaSeleccionada(AtaqueBase ataqueMagico)
    {
        if (HSM.heroe.manaActual >= ataqueMagico.coste)
        {
            //Reset menu selector de magias
            ResetMenuSeleccion();

            sistemaMenus.SeleccionarObjetivo(ataqueMagico);
        }
    }
コード例 #4
0
    // Use this for initialization
    void Start()
    {
        animacion          = this.GetComponent <Animator> ();
        entradaAlternativa = GetComponent <InputWrapper> ();

        AtaqueBase[] scripts = GetComponents <AtaqueBase>();
        Array.Sort(scripts);
        ataque1 = scripts[0];
        ataque2 = scripts[1];

        secureJumpTimeInFixedIntervals *= Time.fixedDeltaTime;
    }
コード例 #5
0
    public void Rellenar(AtaqueBase ataqueMagico)
    {
        if (ataqueMagico.icon != null)
        {
            transform.Find("Icon").GetComponent <Image>().sprite = ataqueMagico.icon;
        }

        transform.Find("Nombre").GetComponent <TextMeshProUGUI>().text = ataqueMagico.nombreAtaque;
        transform.Find("Mana").GetComponent <TextMeshProUGUI>().text   = "<color=#00bdff>mp:<color=white> " + ataqueMagico.coste;
        transform.Find("DMG").GetComponent <TextMeshProUGUI>().text    = "" + ataqueMagico.damage;

        transform.Find("Descripcion").GetComponent <TextMeshProUGUI>().text = ataqueMagico.descripcion;
    }
コード例 #6
0
    public void LanzarMagia(AtaqueBase magia, GameObject enemigo)
    {
        ataque                 = new HandleAction();
        ataque.atacante        = heroe.nombre;
        ataque.tipoAtacante    = HandleAction.TipoAtacante.PERSONAJE;
        ataque.atacanteGameObj = gameObject;
        ataque.ataque          = magia;

        //Seleccionamos el objetivo
        ataque.objetivoGameObj = enemigo;

        //Eliminar Mana
        heroe.manaActual -= magia.coste;
        sistemaTurnos.sistemaDMG.GastarMana();

        //Añadimos la accion al sistema de batalla
        sistemaTurnos.RealizarAccion(ataque);

        StartCoroutine(Accion(enemigo));
    }
コード例 #7
0
 private float calcularModificador(AtaqueBase ataque, EnemigoBase enemigo)
 {
     if (ataque.elementoAtaque.Equals(AtaqueBase.ElementoAtaque.AGUA) && enemigo.elemento.Equals(EnemigoBase.Elemento.FUEGO) ||
         ataque.elementoAtaque.Equals(AtaqueBase.ElementoAtaque.FUEGO) && enemigo.elemento.Equals(EnemigoBase.Elemento.PLANTA) ||
         ataque.elementoAtaque.Equals(AtaqueBase.ElementoAtaque.PLANTA) && enemigo.elemento.Equals(EnemigoBase.Elemento.AGUA) ||
         ataque.elementoAtaque.Equals(AtaqueBase.ElementoAtaque.ELECTRICO) && enemigo.elemento.Equals(EnemigoBase.Elemento.AGUA) ||
         ataque.elementoAtaque.Equals(AtaqueBase.ElementoAtaque.LUZ) && enemigo.elemento.Equals(EnemigoBase.Elemento.OSCURIDAD) ||
         ataque.elementoAtaque.Equals(AtaqueBase.ElementoAtaque.OSCURIDAD) && enemigo.elemento.Equals(EnemigoBase.Elemento.LUZ))
     {
         return(2f);
     }
     else if (ataque.elementoAtaque.Equals(AtaqueBase.ElementoAtaque.FUEGO) && enemigo.elemento.Equals(EnemigoBase.Elemento.AGUA) ||
              ataque.elementoAtaque.Equals(AtaqueBase.ElementoAtaque.PLANTA) && enemigo.elemento.Equals(EnemigoBase.Elemento.FUEGO) ||
              ataque.elementoAtaque.Equals(AtaqueBase.ElementoAtaque.AGUA) && enemigo.elemento.Equals(EnemigoBase.Elemento.PLANTA) ||
              ataque.elementoAtaque.Equals(AtaqueBase.ElementoAtaque.AGUA) && enemigo.elemento.Equals(EnemigoBase.Elemento.ELECTRICO))
     {
         return(0.5f);
     }
     else
     {
         return(1f);
     }
 }
コード例 #8
0
    public void HacerDMG(HandleAction accion)
    {
        HeroeBase   heroe;
        EnemigoBase enemigo;
        int         daño   = 0;
        AtaqueBase  ataque = accion.ataque;

        float modificadorFuerza       = 0.5f;
        float modificadorInteligencia = 0.5f;

        if (accion.atacanteGameObj.CompareTag("Player"))
        {
            heroe   = accion.atacanteGameObj.GetComponent <HeroeStateMachine>().heroe;
            enemigo = accion.objetivoGameObj.GetComponent <EnemigoStateMachine>().enemigo;

            if (accion.ataque.tipoAtaque.Equals(AtaqueBase.TipoAtaque.FISICO))
            {
                daño = Mathf.RoundToInt((((heroe.fuerza * modificadorFuerza) + accion.ataque.damage) - (enemigo.resistenciaF)));
            }
            else if (accion.ataque.tipoAtaque.Equals(AtaqueBase.TipoAtaque.MAGICO))
            {
                daño = Mathf.RoundToInt((((heroe.inteligencia * modificadorInteligencia) + accion.ataque.damage) - (enemigo.resistenciaM)) * calcularModificador(ataque, enemigo));
            }

            if (daño < 0)
            {
                daño = 0;
            }

            accion.damage = daño;
            accion.objetivoGameObj.GetComponent <EnemigoStateMachine>().enemigo.vidaActual -= accion.damage;

            if (accion.objetivoGameObj.GetComponent <EnemigoStateMachine>().enemigo.vidaActual < 0)
            {
                accion.objetivoGameObj.GetComponent <EnemigoStateMachine>().enemigo.vidaActual = 0;
            }

            accion.objetivoGameObj.GetComponent <EnemigoStateMachine>().AnimacionRecibirDMG();
            statHandler.ActualizarInfo();
        }
        else if (accion.atacanteGameObj.CompareTag("Enemigo"))
        {
            enemigo = accion.atacanteGameObj.GetComponent <EnemigoStateMachine>().enemigo;
            heroe   = accion.objetivoGameObj.GetComponent <HeroeStateMachine>().heroe;

            if (accion.ataque.tipoAtaque.Equals(AtaqueBase.TipoAtaque.FISICO))
            {
                daño = Mathf.RoundToInt((((enemigo.fuerza * modificadorFuerza) + accion.ataque.damage) - (heroe.resistenciaF)));
            }
            else if (accion.ataque.tipoAtaque.Equals(AtaqueBase.TipoAtaque.MAGICO))
            {
                daño = Mathf.RoundToInt((((enemigo.inteligencia * modificadorInteligencia) + accion.ataque.damage) - (heroe.resistenciaM)));
            }

            if (daño < 0)
            {
                daño = 0;
            }

            accion.damage = daño;
            accion.objetivoGameObj.GetComponent <HeroeStateMachine>().heroe.vidaActual -= accion.damage;

            if (accion.objetivoGameObj.GetComponent <HeroeStateMachine>().heroe.vidaActual < 0)
            {
                accion.objetivoGameObj.GetComponent <HeroeStateMachine>().heroe.vidaActual = 0;
            }

            accion.objetivoGameObj.GetComponent <HeroeStateMachine>().AnimacionRecibirDMG();
        }

        SpawnDMG(daño, accion.objetivoGameObj, "daño");
        sistemaMenus.sistemaBreak.IncrementarBarra(daño * 0.015f);
    }