示例#1
0
    public IEnumerator ManualCharacterActionPhase(List <Enemy> combatEnemyCopies, List <HeroClass> combatHeroCopies)
    {
        if (gameManager.currentGamePhase == GameManager.GamePhase.Combat)
        {
            for (int i = 0; i < combatOrder.Count; i++)
            {
                PopulateCombatPanel(combatHeroCopies, combatEnemyCopies);

                yield return(new WaitForSeconds(1.5f));

                Character currentCharacter = combatOrder[i];

                currentCharacter.ResolveStatusEffect();

                if (currentCharacter.isStunned == false)
                {
                    if (currentCharacter.GetType() == typeof(HeroClass))
                    {
                        HeroClass currentHero = currentCharacter as HeroClass;


                        if (currentHero.isSpecialReady)
                        {
                            heroMarkers[ListIndex(combatHeroCopies, currentHero)].color = specialReadyColor;
                        }
                        else
                        {
                            heroMarkers[ListIndex(combatHeroCopies, currentHero)].color = selectionColor;
                        }

                        bool isHealer  = (currentHero.role == HeroRole.Mender) ? true : false;
                        bool isHealing = new bool();

                        if (isHealer)
                        {
                            if (combatHeroCopies.Count == 1 && combatHeroCopies[0] == currentHero)
                            {
                                if (currentHero.currentHealth != currentHero.Health)
                                {
                                    isHealing = true; //Is alone, and not at full health
                                }
                                else
                                {
                                    isHealing = false; //Is alone, but at full health
                                }
                            }
                            else
                            {
                                foreach (HeroClass hero in combatHeroCopies)
                                {
                                    if (hero.currentHealth == hero.Health)
                                    {
                                        isHealing         = false; //This hero doesn't need healing;
                                        hero.needsHealing = false;
                                    }
                                    else
                                    {
                                        isHealing         = true; //This hero does need healing
                                        hero.needsHealing = true;
                                    }
                                }
                            }
                        }


                        //Hero Action, pauses for user input
                        switch (isHealing)
                        {
                        case true:
                            HeroClass heroToHeal = null;

                            if (currentHero.isSpecialReady)
                            {
                                currentHero.UseSpecialAbility(null, this, null, combatHeroCopies.ToArray());
                            }

                            foreach (HeroClass hero in combatHeroCopies)
                            {
                                if (hero.currentHealth < hero.Health)
                                {
                                    heroMarkers[ListIndex(combatHeroCopies, hero)].color = targetColor;
                                }
                            }

                            targetNeeded = true;

                            do
                            {
                                yield return(null);
                            } while (targetNeeded == true);

                            heroToHeal = combatHeroCopies[ListIndex(combatHeroCopies, target as HeroClass)];

                            currentHero.BasicHeal(heroToHeal);

                            targetNeeded = false;
                            target       = null;

                            break;

                        case false:
                            Enemy enemyToAttack = null;

                            targetNeeded = true;

                            foreach (Enemy enemy in combatEnemyCopies)
                            {
                                enemyMarkers[EnemyListIndex(combatEnemyCopies, enemy)].color = targetColor;
                            }

                            do
                            {
                                yield return(null);
                            } while (targetNeeded == true);

                            enemyToAttack = combatEnemyCopies[EnemyListIndex(combatEnemyCopies, target as Enemy)];

                            if (currentHero.isSpecialReady)
                            {
                                currentHero.UseSpecialAbility(enemyToAttack, this, combatEnemyCopies, combatEnemyCopies.ToArray());
                            }
                            else
                            {
                                currentHero.BasicAttack(enemyToAttack, this, combatEnemyCopies);
                            }

                            targetNeeded = false;
                            target       = null;

                            break;
                        }
                    }
                    else if (currentCharacter.GetType() == typeof(Enemy))
                    {
                        Enemy currentEnemy = currentCharacter as Enemy;

                        enemyMarkers[EnemyListIndex(combatEnemyCopies, currentEnemy)].color = selectionColor;

                        yield return(new WaitForSeconds(1.5f));

                        HeroClass target = combatHeroCopies[Random.Range(0, combatHeroCopies.Count)];

                        if (target.role == HeroRole.Fencer && target.isSpecialReady)
                        {
                            target.UseSpecialAbility(currentEnemy, this, combatEnemyCopies);
                        }
                        else
                        {
                            currentEnemy.BasicAttack(target, this, combatHeroCopies);
                        }
                    }
                }
                else
                {
                    gameLog.text = combatOrder[i].name + " is Stunned and cannot move.";
                }

                if (i <= (combatOrder.Count - 1) && combatOrder[i].uniqueID != currentCharacter.uniqueID)
                {
                    i--;
                }

                if ((i == combatOrder.Count || i == combatOrder.Count - 1) && (combatHeroCopies.Count > 0 && combatEnemyCopies.Count > 0))
                {
                    i = -1;
                }
                else if (combatHeroCopies.Count <= 0 || combatEnemyCopies.Count <= 0)
                {
                    if (combatHeroCopies.Count <= 0)
                    {
                        gameLog.text += ("\n The Party Was Defeated...");
                        yield return(new WaitForSeconds(1.0f));

                        EndCombat(combatHeroCopies);
                    }

                    if (combatEnemyCopies.Count <= 0)
                    {
                        gameLog.text += ("\n The Party Has Destroyed The Enemy!");
                        yield return(new WaitForSeconds(1.0f));

                        EndCombat(combatHeroCopies, true);
                    }
                }

                yield return(new WaitForSeconds(1.5f));
            }
        }
    }
示例#2
0
    public IEnumerator AutomatedCharacterActionPhase(List <Enemy> combatEnemyCopies, List <HeroClass> combatHeroCopies)
    {
        if (gameManager.currentGamePhase == GameManager.GamePhase.Combat)
        {
            for (int i = 0; i < combatOrder.Count; i++)
            {
                PopulateCombatPanel(combatHeroCopies, combatEnemyCopies);

                Character currentCharacter = combatOrder[i];

                if (gameManager.currentGamePhase == GameManager.GamePhase.Combat)
                {
                    combatOrder[i].ResolveStatusEffect();

                    if (combatOrder[i].isStunned == false)
                    {
                        bool isHealer = new bool();

                        if (combatOrder[i].GetType() == typeof(HeroClass))
                        {
                            yield return(new WaitForSeconds(1.0f));

                            HeroClass currentHero = combatOrder[i] as HeroClass;

                            heroMarkers[ListIndex(heroParty, currentHero)].color = selectionColor;

                            yield return(new WaitForSeconds(0.5f));

                            isHealer = (currentHero.name == "Mender") ? true : false;

                            bool isHealing = new bool();

                            if (isHealer)
                            {
                                if (combatHeroCopies.Count == 1 && combatHeroCopies[0] == currentHero)
                                {
                                    if (currentHero.currentHealth != currentHero.Health)
                                    {
                                        isHealing = true;
                                    }
                                    else
                                    {
                                        isHealing = false;
                                    }
                                }
                                else
                                {
                                    foreach (HeroClass hero in combatHeroCopies)
                                    {
                                        if (hero.currentHealth == hero.Health)
                                        {
                                            isHealing = false;
                                        }
                                        else
                                        {
                                            isHealing = true;
                                        }
                                    }
                                }
                            }

                            switch (isHealing)
                            {
                            case true:
                                HeroClass heroToHeal = currentHero;

                                foreach (HeroClass hero in combatHeroCopies)
                                {
                                    double heroHealthPerc = (hero.currentHealth / hero.Health) * 100;             //Grab % health of 'hero'

                                    double tempHealthPerc = (heroToHeal.currentHealth / heroToHeal.Health) * 100; //Grab % health of heroToHeal

                                    //If hero's Health% is less than the current heroToHeal's, make 'hero' the new heroToHeal
                                    if (heroHealthPerc < tempHealthPerc)
                                    {
                                        heroToHeal = hero;
                                    }
                                }

                                currentHero.BasicHeal(heroToHeal);     //Heals the party member with the lowest percent health
                                break;

                            case false:
                                currentHero.BasicAttack(combatEnemyCopies[Random.Range(0, combatEnemyCopies.Count)], this, combatEnemyCopies);
                                break;
                            }
                        }
                        else
                        {
                            yield return(new WaitForSeconds(1.0f));

                            Enemy currentEnemy = combatOrder[i] as Enemy;

                            enemyMarkers[EnemyListIndex(enemyParty, currentEnemy)].color = selectionColor;

                            yield return(new WaitForSeconds(0.5f));

                            currentEnemy.BasicAttack(combatHeroCopies[Random.Range(0, combatHeroCopies.Count)], this, combatHeroCopies);
                        }

                        if (combatOrder[i] != currentCharacter)
                        {
                            i--;
                        }

                        if ((i == combatOrder.Count || i == combatOrder.Count - 1) && (combatHeroCopies.Count > 0 && combatEnemyCopies.Count > 0))
                        {
                            i = -1;
                        }
                        else if (combatHeroCopies.Count <= 0 || combatEnemyCopies.Count <= 0)
                        {
                            if (combatHeroCopies.Count <= 0)
                            {
                                gameLog.text += ("\n The Party Was Defeated...");
                                yield return(new WaitForSeconds(1.0f));

                                EndCombat(combatHeroCopies);
                            }

                            if (combatEnemyCopies.Count <= 0)
                            {
                                gameLog.text += ("\n The Party Has Destroyed The Enemy!");
                                yield return(new WaitForSeconds(1.0f));

                                EndCombat(combatHeroCopies, true);
                            }
                        }
                    }
                    else
                    {
                        gameLog.text = combatOrder[i].name + " is Stunned and cannot move.";
                    }
                }
            }
        }
        else
        {
            StopAllCombatImmeadiately();
        }
    }