protected override void Activate()
    {
        GameObject      obj = Instantiate(projectile, gameObject.transform.position + new Vector3(0f, 2f, 0f), new Quaternion());
        HorizontalSwipe pbh = obj.GetComponent <HorizontalSwipe>();

        obj.transform.LookAt(mpd.CalculateWorldPosition());
        var lookPos = mpd.CalculateWorldPosition() - transform.position;

        lookPos.y = 0;
        var rotation = Quaternion.LookRotation(lookPos);

        obj.transform.localScale = new Vector3(5f, 5f, 5f);
        pbh.speed = projSpeed;
        Damage dmg = new Damage(0f, Random.Range(dmgMin, dmgMax), false, false, true);

        pbh.dmg = stats.RealDamage(dmg);
        TimedBuff tb   = slowdown.Instance;
        Stat      stat = tb.Stats.Find(item => item.Name == Stat.MOVE_SPEED_MULT);

        // Debug.Log("just like the white winged dove : " + stat.Name + stat.Value + slowdownMult);
        stat = new Stat(stat.Name, StatBlock.CalcMult(stat.Value, slowdownMult));
        tb.Stats.Remove(new Stat(Stat.MOVE_SPEED_MULT));
        tb.Stats.Add(stat);
        tb.Duration += slowdownDur;
        tb.IsUnique  = !slowdownStack;
        pbh.dmg.buffs.Add(tb);
        pbh.friendly = true;
        pbh.ttl      = 4000f;
        pbh.player   = gameObject;
    }
 void Update()
 {
     if (abil.cdRemain > 0f)
     {
         float mult = 1;
         if (stats != null)
         {
             mult += 1 + StatBlock.CalcMult(stats.Cdr, stats.CdrMult);
             if (abil.isAttack)
             {
                 mult += StatBlock.CalcMult(stats.AttackSpeed, stats.AttackSpeedMult);
             }
         }
         abil.cdRemain -= Time.deltaTime * mult;
     }
     if (abil.use)
     {
         abil.use = false;
         Use();
     }
     if (abil.update)
     {
         abil.update = false;
         UpdateStats();
     }
 }
    // Update is called once per frame
    void Update()
    {
        //Debug.Log(stats.Fort + " mult: " + stats.FortMult);
        statlist.text = StatBlock.CalcMult(stats.Str, stats.StrMult).ToString("n1") + "\n" +
                        StatBlock.CalcMult(stats.Dex, stats.DexMult).ToString("n1") + "\n" +
                        StatBlock.CalcMult(stats.Myst, stats.MystMult).ToString("n1") + "\n" +
                        StatBlock.CalcMult(stats.Fort, stats.FortMult).ToString("n1");
        StatBlock detailedStats = stats.getStats();

        column1.text = detailedStats.HealthMax.ToString("n1") + "\n" +
                       StatBlock.CalcMult(detailedStats.HealthRegen, detailedStats.HealthRegenMult).ToString("n1") + "\n" +
                       StatBlock.CalcMult(detailedStats.Armor, detailedStats.ArmorMult).ToString("n1") + "\n" +
                       StatBlock.CalcMult(detailedStats.MoveSpeed, detailedStats.MoveSpeedMult).ToString("n1") + "\n" +
                       StatBlock.CalcMult(detailedStats.AttackSpeed, detailedStats.AttackSpeedMult).ToString("n1");
        column2.text = (StatBlock.CalcMult(detailedStats.Cdr, detailedStats.CdrMult) * 100).ToString("n1") + "%\n" +
                       StatBlock.CalcMult(detailedStats.Spell, detailedStats.SpellMult).ToString("n1") + "\n" +
                       StatBlock.CalcMult(detailedStats.MagicRes, detailedStats.MagicResMult).ToString("n1") + "\n" +
                       (StatBlock.CalcMult(detailedStats.StatusRec, detailedStats.StatusRecMult) * 100).ToString("n1") + "%\n" +
                       (StatBlock.CalcMult(detailedStats.AfflictRes, detailedStats.AfflictResMult) * 100).ToString("n1") + "%";
        column3.text = StatBlock.CalcMult(detailedStats.RangedAttack, detailedStats.RangedAttackMult).ToString("n1") + "\n" +
                       StatBlock.CalcMult(detailedStats.MeleeAttack, detailedStats.MeleeAttackMult).ToString("n1") + "\n" +
                       StatBlock.CalcMult(detailedStats.Damage, detailedStats.DamageMult).ToString("n1") + "\n" +
                       (StatBlock.CalcMult(detailedStats.CritDamage, detailedStats.CritDamageMult) * 100).ToString("n1") + "%\n" +
                       (StatBlock.CalcMult(detailedStats.CritChance, detailedStats.CritChanceMult) * 100).ToString("n1") + "%";
        levelText.text    = player.PlayerLevelExp.Level.ToString();
        nameText.text     = player.bloodlineController.playerName;
        classAgeText.text = textPlayerClass.ClassL.name + "\n" + player.bloodlineController.Age + " cycles";
    }
    protected override void Activate()
    {
        GameObject       obj = Instantiate(projectile, gameObject.transform.position + new Vector3(0, 1.5f, 0), new Quaternion());
        ProjectileBehave pbh = obj.GetComponentInChildren <ProjectileBehave>();
        var lookPos          = mpd.CalculateWorldPosition() - transform.position;

        lookPos.y = 0;
        var rotation = Quaternion.LookRotation(lookPos);

        obj.transform.rotation = Quaternion.Slerp(transform.rotation, rotation, 1f);
        obj.transform.Translate(Vector3.forward * 1.3f);
        obj.transform.localScale = new Vector3(3.3f, 1f, 3.3f);
        Damage dmg;

        if (cost < 0.00001)
        {
            dmg = new Damage(Random.Range(dmgMin, dmgMax), 0, false, true, false);
        }
        else
        {
            float hplost = StatBlock.CalcMult(stats.HealthCur, stats.PhantomHpMult) * cost;
            stats.HealthCur -= hplost;
            Debug.Log("Cost player " + hplost + " hp.");
            dmg = new Damage(Random.Range(dmgMin, dmgMax), hplost / 2f, false, true, true);
        }
        pbh.dmg          = stats.RealDamage(dmg);
        pbh.dmg.callback = this;
    }
示例#5
0
    protected override void Activate()
    {
        TimedBuff tb   = Mend.Instance;
        Stat      stat = tb.Stats.Find(item => item.Name == Stat.HEALTH_REGEN);

        stat.Value = StatBlock.CalcMult(stats.HealthMax * 1.01f, stats.PhantomHpMult) * ratio / tb.Duration;
        controlStats.ApplyBuff(tb);
        stats.HealthCur = 1f;
    }
    protected override void Activate()
    {
        TimedBuff tb     = Block.Instance;
        Stat      stat   = tb.Stats.Find(item => item.Name == Stat.FLAT_DMG_REDUCTION);
        float     hplost = StatBlock.CalcMult(stats.HealthCur, stats.PhantomHpMult) * 0.5f;

        stats.HealthCur -= hplost;
        stat.Value       = hplost / 1000f * mult;
        Debug.Log("Cost player " + hplost + " hp; Dmg Reduction: " + stat.Value + ".");
        controlStats.ApplyBuff(tb);
    }
 public override bool Use()
 {
     if (abil.cdRemain <= 0.0001f && stats.HealthCur > StatBlock.CalcMult(stats.HealthMax, stats.PhantomHpMult) * cost)
     {
         abil.cdRemain = cdBase;
         Activate();
         return(true);
     }
     //else
     return(false);
 }
示例#8
0
    protected override void Activate()
    {
        TimedBuff tb = Dash.Instance;

        tb.Duration += duration;
        Stat stat = tb.Stats.Find(item => item.Name == Stat.MOVE_SPEED_MULT);

        stat = new Stat(stat.Name, StatBlock.CalcMult(stat.Value, dashMult));
        tb.Stats.Remove(new Stat(Stat.MOVE_SPEED_MULT));
        tb.Stats.Add(stat);
        controlStats.ApplyBuff(tb);
    }
示例#9
0
    // Update is called once per frame
    void Update()
    {
        if (taptime > 0 && !fasttimes)
        {
            taptime -= Time.deltaTime;
            if (taptime <= 0)
            {
                fasttimes     = true;
                abil.cdRemain = MajorCooldown;
            }
        }
        if (abil.cdRemain > 0f)
        {
            float mult = 1;
            if (stats != null)
            {
                mult += StatBlock.CalcMult(stats.Cdr, stats.CdrMult);
                if (abil.isAttack)
                {
                    mult += StatBlock.CalcMult(stats.AttackSpeed, stats.AttackSpeedMult);
                }
            }
            abil.cdRemain -= Time.deltaTime * mult;
        }
        if (abil.use)
        {
            abil.use = false;
            Use();
        }
        if (abil.update)
        {
            abil.update = false;
            UpdateStats();
        }

        if (ttl > 0)
        {
            // Debug.Log("big if true");
            ttl          -= Time.deltaTime;
            destination.y = transform.position.y;
            if (Vector3.Distance(destination, this.transform.position) < 1.0f)
            {
                destination = this.transform.position;
            }
            transform.position = Vector3.MoveTowards(transform.position, destination, fastness * Time.deltaTime);
        }
        if (Input.GetMouseButtonDown(0) || ttl <= 0)
        {
            fastness = 0;
        }
    }
    protected override void Activate()
    {
        GameObject       obj = Instantiate(projectile, gameObject.transform.position + new Vector3(0, 1.5f, 0), new Quaternion());
        ProjectileBehave pbh = obj.GetComponentInChildren <ProjectileBehave>();

        obj.transform.localScale = new Vector3(10.3f, 1f, 10.3f);
        Damage dmg;
        float  hplost = StatBlock.CalcMult(stats.HealthMax, stats.PhantomHpMult) * cost;

        stats.HealthCur -= hplost;
        Debug.Log("Cost player " + hplost + " hp.");
        dmg     = new Damage(0f, hplost * dmgRatio, false, false, true);
        pbh.dmg = stats.RealDamage(dmg);
    }
示例#11
0
    // Update is called once per frame
    new void Update()
    {
        base.Update();
        if (active)
        {
            if (!inUse)
            {
                timeSinceUse += Time.deltaTime;
                if (Vector3.Distance(transform.position, player.transform.position) > 6)
                {
                    transform.Translate(Vector3.forward * Time.deltaTime * StatBlock.CalcMult(stats.MoveSpeed, stats.MoveSpeedMult));

                    if (!animator.GetCurrentAnimatorStateInfo(0).IsName("walk"))
                    {
                        //Debug.Log("set walk");
                        animator.SetTrigger("walk");
                    }
                }
                else
                {
                    if (!animator.GetCurrentAnimatorStateInfo(0).IsName("idle"))
                    {
                        //Debug.Log("set walk");
                        animator.SetTrigger("idle");
                    }
                }
            }

            if (timeSinceUse > cooldown)
            {
                animator.SetTrigger("idle");
                timeSinceUse = 0;
                inUse        = true;
                switch (nextAttack)
                {
                case 0:
                    AbilityZero();
                    break;

                case 1:
                    AbilityOne();
                    break;

                case 2:
                    AbilityTwo();
                    break;
                }
            }
        }
    }
示例#12
0
    // Start is called before the first frame update
    void Start()
    {
        //initialPosition = new Vector3(5, 5, 5);
        EPSSION       = 0.0001f;
        reLocateDelay = 0.15f;
        rotationSpeed = 20;

        statBlock   = GetComponent <StatBlock>();
        movingSpeed = StatBlock.CalcMult(statBlock.MoveSpeed, statBlock.MoveSpeedMult);

        animator = GetComponent <Animator>();
        animator.SetBool("isRunning", false);
        //this.transform.position = initialPosition;
        destination = transform.position; //initialPosition;
    }
示例#13
0
    public void AgeUp()
    {
        float rand = Random.Range(0f, pClass.bloodlineController.Age / 2f);

        Debug.Log("Age: " + pClass.bloodlineController.Age + " Rand: " + rand + " Fort: " + StatBlock.CalcMult(stats.AfflictRes, stats.AfflictResMult));
        if (rand - 3f > StatBlock.CalcMult(stats.AfflictRes, stats.AfflictResMult))
        {
            Affliction aff = init.BadAffList.afflictions[Random.Range(0, init.BadAffList.afflictions.Count)];
            Debug.Log("Gained affliction: " + aff.AfflictionName);
            afflictions.Add(aff);
        }
        else if (rand + 1.5f < StatBlock.CalcMult(stats.AfflictRes, stats.AfflictResMult))
        {
            Affliction aff = init.GoodAffList.afflictions[Random.Range(0, init.GoodAffList.afflictions.Count)];
            Debug.Log("Gained affliction: " + aff.AfflictionName);
            afflictions.Add(aff);
        }
    }
示例#14
0
    void Move()
    {
        Vector3 differ = transform.position - destination;

        if ((differ.x > EPSSION || differ.x < -EPSSION) || (differ.z < -EPSSION || differ.z > EPSSION))
        {
            //if (transform.position != destination) {

            animator.SetBool("isMelee", false);

            animator.SetBool("isFireballIgnite", false);

            animator.SetBool("isFireballVolley", false);

            animator.SetBool("isAblaze", false);

            animator.SetBool("isMagic4", false);

            animator.SetBool("isEquip", false);

            animator.SetBool("isUnEquip", false);

            animator.SetBool("isEdgySlash", false);

            animator.SetBool("isWhirlwindSlash", false);

            animator.SetBool("isRainOfDeath", false);

            animator.SetBool("isThrowingDagger", false);

            animator.SetBool("isAbilityVampStrike", false);

            animator.SetBool("isRunning", true);

            movingSpeed        = StatBlock.CalcMult(statBlock.MoveSpeed, statBlock.MoveSpeedMult);
            transform.position = Vector3.MoveTowards(transform.position, destination, movingSpeed * Time.deltaTime);
        }
        else
        {
            animator.SetBool("isRunning", false);
        }
    }
示例#15
0
    // Update is called once per frame
    void Update()
    {
        bool needsUpdate = false;

        foreach (TimedBuff tb in buffsToAdd)
        {
            if (tb.IsUnique && buffs.Contains(tb))
            {
                buffs.Remove(tb);
            }
            buffs.Add(tb);
            needsUpdate = true;
        }
        buffsToAdd.Clear();
        for (int i = buffs.Count - 1; i > -1; --i)
        {
            TimedBuff tb = buffs[i];
            if (tb.IsNegative)
            {
                tb.DurationLeft -= Time.deltaTime * (1 + StatBlock.CalcMult(stats.StatusRec, stats.StatusRecMult));
            }
            else
            {
                tb.DurationLeft -= Time.deltaTime;
            }

            //Debug.Log(tb.BuffName + " at " + i + " has " + tb.DurationLeft + " left.");
            if (tb.DurationLeft <= 0f)
            {
                buffs.RemoveAt(i);
                Debug.Log(tb.BuffName + " expired.");
                needsUpdate = true;
            }
        }
        if (needsUpdate)
        {
            StatsChanged();
        }
    }
示例#16
0
    new void Update()
    {
        base.Update();
        if (active)
        {
            timeSinceSpawn += Time.deltaTime;

            if (!inUse && !isDead && timeSinceSpawn > spawnCd)
            {
                timeSinceSpawn = 0;
                spawnCd       += 1.5f;
                cooldown      += 1.5f;
                nextAttack     = 0;
                SpawnAdd();
            }

            if (!inUse)
            {
                timeSinceUse   += Time.deltaTime;
                timeSinceMelee += Time.deltaTime;
                if (Vector3.Distance(transform.position, player.transform.position) > transform.localScale.x + 0.8f)
                {
                    transform.Translate(Vector3.forward * Time.deltaTime * StatBlock.CalcMult(stats.MoveSpeed, stats.MoveSpeedMult));

                    if (!animator.GetCurrentAnimatorStateInfo(0).IsName("run"))
                    {
                        animator.SetTrigger("walk");
                    }
                }
                else
                {
                    if (!animator.GetCurrentAnimatorStateInfo(0).IsName("idle"))
                    {
                        animator.SetTrigger("idle");
                    }
                    if (timeSinceMelee > 0.9f)
                    {
                        timeSinceMelee = 0;
                        MeleeAttackPlayer();
                    }
                }
            }

            if (timeSinceUse > cooldown)
            {
                animator.SetTrigger("idle");
                timeSinceUse = 0;
                inUse        = true;
                switch (nextAttack)
                {
                case 0:
                    AbilityZero();
                    break;

                case 1:
                    AbilityOne();
                    break;

                default:
                    AbilityZero();
                    break;
                }
            }
        }
    }
示例#17
0
    // Update is called once per frame
    new void Update()
    {
        base.Update();
        if (active)
        {
            if (miniPhase == 0 && stats.HealthCur / stats.HealthMax < 0.5)
            {
                miniPhase = 1;
                miniBoss.BecomeWoke(stats, Level, player);
            }
            else if (miniPhase == 1 && stats.HealthCur / stats.HealthMax < 0.25)
            {
                miniPhase = 2;
                miniBoss.PhaseTwo();
            }

            if (!inUse)
            {
                timeSinceUse   += Time.deltaTime;
                timeSinceMelee += Time.deltaTime;
                if (Vector3.Distance(transform.position, player.transform.position) > 5)
                {
                    transform.Translate(Vector3.forward * Time.deltaTime * StatBlock.CalcMult(stats.MoveSpeed, stats.MoveSpeedMult));

                    if (!animator.GetCurrentAnimatorStateInfo(0).IsName("walk"))
                    {
                        //Debug.Log("set walk");
                        animator.SetTrigger("walk");
                    }
                }
                else
                {
                    if (!animator.GetCurrentAnimatorStateInfo(0).IsName("idle"))
                    {
                        //Debug.Log("set walk");
                        animator.SetTrigger("idle");
                    }
                    if (timeSinceMelee > 0.5f)
                    {
                        timeSinceMelee = 0;
                        MeleeAttackPlayer();
                    }
                }
            }

            if (timeSinceUse > cooldown)
            {
                animator.SetTrigger("idle");
                timeSinceUse = 0;
                inUse        = true;
                switch (nextAttack)
                {
                case 0:
                    AbilityZero();
                    break;

                case 1:
                    AbilityOne();
                    break;

                default:
                    AbilityZero();
                    break;
                }
            }
        }
    }
示例#18
0
    // Update is called once per frame
    new void Update()
    {
        base.Update();
        if (active)
        {
            if (!inUse)
            {
                timeSinceUse += Time.deltaTime;
                if (Vector3.Distance(transform.position, player.transform.position) > 5)
                {
                    transform.Translate(Vector3.forward * Time.deltaTime * StatBlock.CalcMult(stats.MoveSpeed, stats.MoveSpeedMult));

                    if (!animator.GetCurrentAnimatorStateInfo(0).IsName("walk"))
                    {
                        //Debug.Log("set walk");
                        animator.SetTrigger("walk");
                    }
                }
                else
                {
                    if (!animator.GetCurrentAnimatorStateInfo(0).IsName("idle"))
                    {
                        //Debug.Log("set walk");
                        animator.SetTrigger("idle");
                    }
                }
            }

            ballTimer += Time.deltaTime;
            while (ballTimer > AbilityBallCd)
            {
                ballTimer -= AbilityBallCd;
                SpawnBall();
            }

            if (flyUp && transform.position.y < floatY)
            {
                transform.Translate(Vector3.up * Time.deltaTime * 5f);
            }
            if (!flyUp && transform.position.y > landY)
            {
                transform.Translate(Vector3.down * Time.deltaTime * 5f);
            }

            if (timeSinceUse > cooldown)
            {
                animator.SetTrigger("idle");
                timeSinceUse = 0;
                inUse        = true;
                switch (nextAttack)
                {
                case 0:
                    AbilityZero();
                    break;

                case 1:
                    AbilityOne();
                    break;

                case 2:
                    AbilityTwo();
                    break;

                default:
                    AbilityZero();
                    break;
                }
            }
        }
    }
示例#19
0
    public void StatsChanged()
    {
        if (oldHpPrecent >= -1000f && stats.HealthMax != 0.0f)
        {
            oldHpPrecent = stats.HealthCur / stats.HealthMax;
        }
        else
        {
            oldHpPrecent = 1f;
        }

        ResetBaseStats();

        if (applyTestStats)
        {
            TestStatIncrease();
        }

        if (inv != null)
        {
            foreach (Item item in inv.Equipment.Equipment.Values)
            {
                foreach (Stat s in item.Stats)
                {
                    ApplyStat(s);
                }
            }
        }

        if (pClass != null)
        {
            foreach (PerkPrototype perk in pClass.TakenPerks)
            {
                foreach (PerkStatEntry sp in perk.Stats)
                {
                    ApplyStat(sp.StatInst);
                }
            }
        }

        foreach (TimedBuff tb in buffs)
        {
            foreach (Stat s in tb.Stats)
            {
                ApplyStat(s);
            }
        }

        foreach (Affliction aff in afflictions)
        {
            foreach (Stat s in aff.Stats)
            {
                ApplyStat(s);
            }
        }

        float strReal = StatBlock.CalcMult(Str, StrMult);

        stats.HealthBase      += strReal * 10f;
        stats.HealthRegen     += strReal / 10f;
        stats.MeleeAttackMult += strReal / 1000f;

        float dexReal = StatBlock.CalcMult(Dex, DexMult);

        stats.AttackSpeedMult  += dexReal / 1000f;
        stats.MoveSpeedMult    += dexReal / 750f;
        stats.RangedAttackMult += dexReal / 1000f;

        float mystReal = StatBlock.CalcMult(Myst, MystMult);

        stats.Cdr       += mystReal / 2000f;
        stats.SpellMult += mystReal / 1000f;

        float fortReal = StatBlock.CalcMult(Fort, FortMult);

        stats.MagicRes   += fortReal / 3f;
        stats.AfflictRes += fortReal / 250f;
        stats.StatusRec  += fortReal / 2000f;

        stats.HealthCur = oldHpPrecent * StatBlock.CalcMult(stats.HealthBase, stats.HealthMult);
    }