Esempio n. 1
0
    static List <ArmAspect> getSpecialIdAspects(int difficultyId, int nArms)
    {
        List <ArmAspect> listArmAspects  = new List <ArmAspect>();
        ArmAspect        specialIdAspect = specialEnemyDict[difficultyId].aspect;

        for (int i = 0; i < nArms; i++)
        {
            listArmAspects.Add(specialIdAspect);
        }
        return(listArmAspects);
    }
Esempio n. 2
0
    void addNewPanel(Vector2 position, ArmManager.ArmAspect armAspect, int nArms)
    {
        GameObject panelObj = Instantiate(emptyPanel);

        panelObj.transform.SetParent(imageContainer);
        RectTransform panelRT = panelObj.GetComponent <RectTransform>();

        panelRT.localScale    = Vector3.one;
        panelRT.localPosition = position;


        if (nArms >= 6)
        {
            GameObject nArmsText = panelRT.GetChild(1).gameObject;
            nArmsText.SetActive(true);
            nArmsText.GetComponent <Text>().text = "x" + nArms;
            if (nArms == 8)
            {
                nArmsText.GetComponent <Text>().color = new Color(0.2f, 0.5f, 0.8f, 1);
            }
        }

        Color  armAspectColor;
        string expBonusText;

        switch (armAspect)
        {
        case ArmManager.ArmAspect.NORMAL:
        default:
            return;

        case ArmManager.ArmAspect.SILVER:
            armAspectColor = new Color(0.68f, 0.95f, 0.9f, 0.39f);
            expBonusText   = "+25%";
            break;

        case ArmManager.ArmAspect.GOLD:
            armAspectColor = new Color(0.96f, 1f, 0.18f, 0.39f);
            expBonusText   = "+50%";
            break;
        }

        panelObj.GetComponent <Image>().color = armAspectColor;
        GameObject extraExpText = panelRT.GetChild(0).gameObject;

        extraExpText.SetActive(true);
        extraExpText.GetComponent <Text>().text = expBonusText + " " + TextScript.get(TextScript.Sentence.EXP);
    }
Esempio n. 3
0
    void applyArmEffect(Arm arm, ArmAspect armAspect)
    {
        switch (arm)
        {
        case Arm.NORMAL:     // No effect
            break;

        case Arm.HOOK:     // Increases chances of dice attack
            possibleAttacks.Add(Attack.DICE_ATTACK);
            if (armAspect == ArmAspect.SILVER)
            {
                diceAttackLv = Mathf.Max(0.5f, diceAttackLv);
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                diceAttackLv = Mathf.Max(1f, diceAttackLv);
            }
            break;

        case Arm.POWER_GLOW:     // +20% damage
            double extraAttack = 1;
            if (armAspect == ArmAspect.NORMAL)
            {
                extraAttack = 1.2;
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                extraAttack = 1.5;
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                extraAttack = 2.5;
            }
            damageAgainstHealth = System.Math.Round(damageAgainstHealth * extraAttack);
            break;

        case Arm.BLADE:     // Increases chances of normal attack
            possibleAttacks.Add(Attack.NORMAL_ATTACK);
            extraAttack = 1;
            if (armAspect == ArmAspect.NORMAL)
            {
                extraAttack = 1;
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                extraAttack = 1.2;
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                extraAttack = 1.5;
            }
            damageAgainstHealth = System.Math.Round(damageAgainstHealth * extraAttack);
            break;

        case Arm.BUZZSAW:     // Allows milling attacks
            possibleAttacks.Add(Attack.MILL);
            if (armAspect == ArmAspect.SILVER)
            {
                buzzsawAttackLv = Mathf.Max(0.5f, buzzsawAttackLv);
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                buzzsawAttackLv = Mathf.Max(0.75f, buzzsawAttackLv);
            }
            break;

        case Arm.SHIELD:     // +20% health
            float extraHealth = 1;
            if (armAspect == ArmAspect.NORMAL)
            {
                extraHealth = 1.2f;
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                extraHealth = 2f;
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                extraHealth = 4f;
            }
            multiplyMaxHealth(extraHealth);
            break;

        case Arm.FAN:     // Allows discarding attacks
            possibleAttacks.Add(Attack.DISCARD);
            if (armAspect == ArmAspect.SILVER)
            {
                fanAttackLv = Mathf.Max(0.5f, fanAttackLv);
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                fanAttackLv = Mathf.Max(0.75f, fanAttackLv);
            }
            break;

        case Arm.GRAPNEL:     // Increases dice damage (default is min .4, max .8)
            if (armAspect == ArmAspect.NORMAL)
            {
                damageAgainstDiceMin += 0.05f;
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                damageAgainstDiceMin += 0.10f;
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                damageAgainstDiceMin += 0.20f;
            }
            damageAgainstDiceMax += 0.2f;
            damageAgainstDiceMin  = Mathf.Min(0.99f, damageAgainstDiceMin);
            damageAgainstDiceMax  = Mathf.Min(1, damageAgainstDiceMax);
            break;

        case Arm.SALVE:     // Allows healing
            possibleAttacks.Add(Attack.HEAL);
            if (armAspect == ArmAspect.NORMAL)
            {
                healLv = Mathf.Max(0.33f, healLv);
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                healLv = Mathf.Max(0.4f, healLv);
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                healLv = Mathf.Max(0.75f, healLv);
            }
            break;

        case Arm.FORBIDDEN_RELIC:     // Deal high damage by paying health
            possibleAttacks.Add(Attack.RECOIL_ATTACK);
            if (armAspect == ArmAspect.NORMAL)
            {
                recoilAttackLv   = Mathf.Max(2, recoilAttackLv);
                recoilAttackCost = System.Math.Max(0.2, recoilAttackCost);
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                recoilAttackLv   = Mathf.Max(4, recoilAttackLv);
                recoilAttackCost = System.Math.Max(0.25, recoilAttackCost);
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                recoilAttackLv   = Mathf.Max(8, recoilAttackLv);
                recoilAttackCost = System.Math.Max(0.3, recoilAttackCost);
            }
            break;

        case Arm.SIPHON:     // Drain health
            possibleAttacks.Add(Attack.DRAIN);
            if (armAspect == ArmAspect.NORMAL)
            {
                drainLv = System.Math.Max(0.33, drainLv);
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                drainLv = System.Math.Max(0.8, drainLv);
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                drainLv = System.Math.Max(1.5, drainLv);
            }
            break;

        case Arm.BATTERY:     // Allows boosting attack
            possibleAttacks.Add(Attack.CHARGE);
            if (armAspect == ArmAspect.NORMAL)
            {
                chargeLv = Mathf.Max(1.2f, chargeLv);
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                chargeLv = Mathf.Max(2f, chargeLv);
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                chargeLv = Mathf.Max(3.5f, chargeLv);
            }
            break;

        case Arm.MIASMA:     // Halve all health gains
            float healMod = 1;
            if (armAspect == ArmAspect.NORMAL)
            {
                healMod = 0.5f;
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                healMod = 0.25f;
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                healMod = 0.1f;
            }
            Player.healingModifier *= healMod;
            break;

        case Arm.AEGIS:     // Lower damage of attack rolls
            float damageReduction = 1;
            if (armAspect == ArmAspect.NORMAL)
            {
                damageReduction = 0.8f;
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                damageReduction = 0.5f;
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                damageReduction = 0.25f;
            }
            protectionShields = 1 - ((1 - protectionShields) * damageReduction);
            break;

        case Arm.CARTILAGE:     // Can curse (x0.5 dice for one turn)
            possibleAttacks.Add(Attack.CURSE);
            if (armAspect == ArmAspect.NORMAL)
            {
                curseLv = System.Math.Min(0.5, curseLv);
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                curseLv = System.Math.Min(0.25, curseLv);
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                curseLv = System.Math.Min(0.1, curseLv);
            }
            break;

        case Arm.FLOE:     // Weaken cards in hand
            possibleAttacks.Add(Attack.WEAKEN_CARDS);
            if (armAspect == ArmAspect.NORMAL)
            {
                floeAttackLv = Mathf.Min(0.85f, floeAttackLv);
            }
            else if (armAspect == ArmAspect.SILVER)
            {
                floeAttackLv = Mathf.Min(0.7f, floeAttackLv);
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                floeAttackLv = Mathf.Min(0.5f, floeAttackLv);
            }
            break;

        case Arm.ILLUSIONIST:     // Swap cards in hand for random ones
            possibleAttacks.Add(Attack.SWAP_CARDS);
            if (armAspect == ArmAspect.SILVER)
            {
                magicianAttackLv = Mathf.Min(0.85f, magicianAttackLv);
            }
            else if (armAspect == ArmAspect.GOLD)
            {
                magicianAttackLv = Mathf.Min(0.7f, magicianAttackLv);
            }
            break;
        }
    }
Esempio n. 4
0
 public SpecialEnemyInfo(int nArms, Arm arm, ArmAspect aspect)
 {
     this.nArms  = nArms;
     this.arm    = arm;
     this.aspect = aspect;
 }
Esempio n. 5
0
 void addNewPanel(Vector2 position, ArmManager.ArmAspect armAspect)
 {
     addNewPanel(position, armAspect, 4);
 }