Example #1
0
    public BattleMemberGroup(Summary1 s1)
    {
        set1(s1);

        for (int t1 = 0; t1 < member_data_max(); t1++)
        {
            battle_member[t1] = new BattleMember(s1, t1);
        }
    }
Example #2
0
 private void ShuffleMembers()
 {
     for (int i = 0; i < m_Members.Length; i++)
     {
         BattleMember temp        = m_Members[i];
         int          randomIndex = Random.Range(0, m_Members.Length);
         m_Members[i]           = m_Members[randomIndex];
         m_Members[randomIndex] = temp;
     }
 }
Example #3
0
 void Strike(BattleMember att, Animator anim1, GameObject defender)
 {
     def   = defender.GetComponent <BattleMember>();
     anim2 = defender.GetComponent <Animator>();
     anim1.SetTrigger("Attack");
     if (((att.accuracy - def.agility / 2) - Random.Range(0, 10)) > 0)
     {
         def.health -= att.damage - def.defence / 2;
         CheckDeath(def, defender);
     }
 }
Example #4
0
 void ChangePosition(GameObject attacker, GameObject defender)
 {
     def = defender.GetComponent <BattleMember>();
     if (def.mood == 1)
     {
         Vector3 x;
         x = attacker.transform.position;
         attacker.transform.position = defender.transform.position;
         defender.transform.position = x;
     }
 }
Example #5
0
    private BattleMember TargetMember(BattleMember attacker)
    {
        if (attacker.characterType == BattleMember.CharacterType.Player)
        {
            return(enemy);
        }

        int num = Random.Range(1, m_Members.Length);

        return(m_Members[num]);
    }
Example #6
0
 public override void Spell(List <GameObject> properties)
 {
     foreach (GameObject enemy in properties)
     {
         BattleMember bt = enemy.GetComponent <BattleMember>();
         if ((accuracy - bt.agility / 2) - Random.Range(0, 100) > 0)
         {
             bt.health = powerOfSpell - bt.powerOfWill / 2;
         }
     }
     couldown = 5;
 }
Example #7
0
        private void UseWeapon(BattleMember bm, Enemy target, int t)
        {
            var    weapon = bm.Weapon;
            int    damage = 0;
            string log    = "";

            switch (weapon.Style)
            {
            case WeaponStyle.LIFESTEAL:
                if (_dh.CanUseNIcons(2))
                {
                    ReduceTurns(FULL * 2);
                    damage = (weapon.Damage + _state.Player.Stats.stats[Stat.ATTACK]) / 2;
                    log    = _dh.GetWeaponResult(bm.Name, damage, _state, target);

                    if (!log.Contains("missed"))
                    {
                        _dgc.ReducePlayerHealth(damage * -1);     // we want to heal, so we make dmg negative
                        log += $" {bm.Name} healed everyone for {damage} HP!";
                    }

                    ProcessDamage(target, t);
                }
                else
                {
                    log = "Not enough icons to use this skill.";
                    MessageBox.Show(log);
                }

                break;

            case WeaponStyle.PARRY:
                if (_dh.CanUseNIcons(2) && !_state.Player.Stats.isParryState)
                {
                    _state.Player.Stats.isParryState = true;
                    log = $"Player team assumes a parry stance!";
                    ReduceTurns(FULL * 2);
                    CheckTurnEnd();
                }
                else
                {
                    MessageBox.Show("You either don't have enough turns or are already in a parry stance.");
                }
                break;

            default:
                log = _dh.GetWeaponResult(bm.Name, weapon.Damage, _state, target);
                ReduceTurns(FULL);
                _dgc.UpdateCombatLog(log);
                ProcessDamage(target, t);
                break;
            }
        }
Example #8
0
        private void UseSkillPlayer(BattleMember bm, Enemy target, int t)
        {
            var    skill  = _dgc.GetSelectedSkill();
            string result = "";

            if (skill != null)
            {
                switch (skill.S_Type)
                {
                case SkillType.OFFENSIVE_BUFF:
                    if (_state.Player.Stats.CanBuff(skill.Stat))
                    {
                        result = $"{bm.Name} used {skill.Name} and buffed their party.";
                        _state.Player.Stats.stats[skill.Stat] += skill.Multiplier;
                        ReduceTurns(FULL);
                    }
                    else
                    {
                        result = "You can't buff that stat any further.";
                        MessageBox.Show(result);
                    }
                    _dgc.UpdateCombatLog(result);
                    CheckTurnEnd();
                    break;

                case SkillType.HEALING:
                    _dgc.ReducePlayerHealth(skill.GetDamage() * -1);
                    ReduceTurns(FULL);
                    result = $"{bm.Name} used {skill.Name} and healed for {skill.GetDamage()} HP";
                    _dgc.UpdateCombatLog(result);
                    CheckTurnEnd();
                    break;

                default:
                    result = _dh.GetSkillResult(bm.Name, _state, skill, target);

                    if (result.Contains("critical") || result.Contains("weakness"))
                    {
                        ReduceTurns(HALF);
                    }
                    else
                    {
                        ReduceTurns(FULL);
                    }

                    _dgc.UpdateCombatLog(result);

                    ProcessDamage(target, t);

                    break;
                }
            }
        }
Example #9
0
    public override void Spell(List <GameObject> properties)
    {
        BattleMember bt = properties[0].GetComponent <BattleMember>();

        for (int i = 0; i < 3; i++)
        {
            if ((accuracy - bt.agility / 2) - Random.Range(0, 100) > 0)
            {
                bt.health -= powerOfSpell - bt.powerOfWill / 2;
            }
        }
        couldown = 3;
    }
Example #10
0
        public void UpdateSkillBoxSkills(BattleMember bm)
        {
            var skills = bm.Skills.FindAll(s => s.S_Type == SkillType.OFFENSIVE ||
                                           s.S_Type == SkillType.HEALING ||
                                           s.S_Type == SkillType.OFFENSIVE_BUFF);

            skills.Sort((a, b) => a.GetDamage().CompareTo(b.GetDamage()));
            skills.Reverse();
            skillBox.Items.Clear();
            skillBox.Items.Add("~ Skills ~");
            skills.ForEach(s => skillBox.Items.Add(s));
            skillBox.Items.Add(bm.Weapon.DisplayString());
        }
Example #11
0
 void CheckDeath(BattleMember def, GameObject defender)
 {
     if (def.health <= 0)
     {
         if (turnPlayer)
         {
             enemiesG.Remove(defender);
             k--;
         }
         else
         {
             if (turnEnemy)
             {
                 playersG.Remove(defender);
                 i--;
             }
         }
     }
 }
Example #12
0
    // Update is called once per frame
    void FixedUpdate()
    {
        if (!doingSetup)
        {
            if (turnPlayer)
            {
                if (i == playersG.Count || i < 0)
                {
                    i = 0;
                }
                movingPerson = playersG[i];
                att          = movingPerson.GetComponent <BattleMember>();;
                anim1        = movingPerson.GetComponent <Animator>();
                spell        = movingPerson.GetComponent <Spell>();
                for (int r = 0; r < spell.A_Attribute.sprites.Count(); r++)
                {
                    hud.icons[r].sprite = spell.A_Attribute.sprites[r];
                }
                if (Input.GetMouseButtonDown(0) && FindObj() != null)
                {
                    if (action == 1 && Input.GetMouseButtonDown(0))
                    {
                        Strike(att, anim1, FindObj());
                    }

                    if (action == 2 && Input.GetMouseButtonDown(0) && att.couldown == 0)
                    {
                        CastSpell(att, anim1);
                    }

                    if (action == 3 && Input.GetMouseButtonDown(0))
                    {
                    }

                    if (action == 4 && Input.GetMouseButtonDown(0))
                    {
                        ChangePosition(movingPerson, FindObj());
                    }
                    turnPlayer = false;
                    turnEnemy  = true;
                    i++;
                    StartCoroutine(WaitMore());
                    wait = true;
                }
            }
            if (enemiesG.Count == 0 || playersG.Count == 0)
            {
                if (playersG.Count == 0)
                {
                    Application.Quit();
                }
                if (enemiesG.Count == 0)
                {
                    Invoke("Victory", 5f);
                    player.squad = playersG;
                }
            }
            if (turnEnemy && wait)
            {
                if (k == enemiesG.Count)
                {
                    k = 0;
                }
                movingPerson = enemiesG[k];
                att          = movingPerson.GetComponent <BattleMember>();
                anim1        = movingPerson.GetComponent <Animator>();
                if (att.couldown == 0)
                {
                    CastSpell(att, anim1);
                    att.couldown = 5;
                }
                else
                {
                    Strike(att, anim1, playersG[Random.Range(0, playersG.Count - 1)]);
                }
                turnPlayer = true;
                turnEnemy  = false;
                k++;
                wait = false;
            }
            Debug.Log(enemiesG.Count);
        }
    }
Example #13
0
 void CastSpell(BattleMember att, Animator anim1)
 {
     anim1.SetTrigger("Spell");
     att.Spell(enemiesG);
 }
Example #14
0
 public void AddBattleMember(BattleMember unit)
 {
     squad.Add(unit);
 }
Example #15
0
 public void RemoveBattleMember(BattleMember unit)
 {
     squad.Remove(unit);
 }
Example #16
0
 // Start is called before the first frame update
 void Start()
 {
     pb = character.GetComponent <BattleMember>();
     SetMaxHealth();
 }