public override int Generate(BattleActorInfo attacker, BattleActorInfo defender, int turn, int actionCount)
    {
        // current stat * RANDBETWEEN(1, 5) + RANDBETWEEN(1, 10)
        int dmg = attacker.Value * random.Range(Multiplier.Minimum, Multiplier.Maximum, turn, actionCount) + random.Range(AdditionMultiplier.Minimum, AdditionMultiplier.Maximum, turn, actionCount);

        return(ApplyDefense(dmg, defender, turn, actionCount));
    }
Beispiel #2
0
    public override int Generate(BattleActorInfo attacker, BattleActorInfo defender, int turn, int actionCount)
    {
        //Curent stat * EXP(current E Value x ((current level / RANDBETWEEN(98, 115)) * 3))
        int dmg = (int)(attacker.Value * Mathf.Exp(StatUtils.CalcEValue(attacker.Level, attacker.Stats.Limit) * ((attacker.Level / random.Range(Multiplier.Minimum, Multiplier.Maximum, turn, actionCount)) * 3)));

        return(ApplyDefense(dmg, defender, turn, actionCount));
    }
    public override int Generate(BattleActorInfo attacker, BattleActorInfo defender, int turn, int actionCount)
    {
        //POWER(current stat, 2) / (current stat / RANDBETWEEN(3, 10))
        int dmg = (int)(Mathf.Pow(attacker.Value, 2) / (attacker.Value / random.Range(Multiplier.Minimum, Multiplier.Maximum, turn, actionCount)));

        return(ApplyDefense(dmg, defender, turn, actionCount));
    }
Beispiel #4
0
    public override int Generate(BattleActorInfo attacker, BattleActorInfo defender, int turn, int actionCount)
    {
        int maxStat  = StatUtils.CalcMaxStat(attacker.Level);
        int modifier = Mathf.Abs(random.Range(Multiplier.Minimum, Multiplier.Maximum, turn, actionCount) - (maxStat - attacker.Value) / maxStat) * maxStat;
        int dmg      = (int)(Mathf.Log10(attacker.Value) / Mathf.Log10(maxStat) * maxStat + modifier);

        return(ApplyDefense(dmg, defender, turn, actionCount));
    }
    protected int ApplyDefense(int rawDamage, BattleActorInfo defender, int turn, int actionCount)
    {
        double value = 0.0;

        if (DefenseMultiplier.Minimum < DefenseMultiplier.Maximum)
        {
            value = defender.Value / (StatUtils.CalcMaxStat(defender.Stats.Limit) * random.Range(DefenseMultiplier.Minimum, DefenseMultiplier.Maximum, turn, actionCount));
        }
        else if (DefenseMultiplier.Maximum > 0)
        {
            value = defender.Value / (StatUtils.CalcMaxStat(defender.Stats.Limit) * DefenseMultiplier.Maximum);
        }
        else
        {
            value = defender.Value / (StatUtils.CalcMaxStat(defender.Stats.Limit));
        }
        int dmg = rawDamage - (int)value;

        if (dmg < 0)
        {
            dmg = 0;
        }
        return(dmg);
    }
 public abstract T Generate(BattleActorInfo attacker, BattleActorInfo defender, int turn, int actionCount);
    public override int Generate(BattleActorInfo attacker, BattleActorInfo defender, int turn, int actionCount)
    {
        int dmg = (int)(attacker.Value * Mathf.Pow(random.Range(Multiplier.Minimum, Multiplier.Maximum), StatUtils.CalcEValue(attacker.Level, attacker.Stats.Limit)));

        return(ApplyDefense(dmg, defender, turn, actionCount));
    }
Beispiel #8
0
    public override void BattleStep()
    {
        Debug.Log("=== Turn " + Turn);
        Entity[] actors = GetNextActingEntities();
        foreach (Entity actor in actors)
        {
            BattleStats actorStat;
            if (stats.TryGetValue(actor, out actorStat))
            {
                //TODO select target that can be targeted, don't select downed opposing members
                Entity target = null;
                if (BattleManager.EnemyParty.Contains(actor))
                {
                    int index = AcquireValidTarget(BattleManager.PlayerParty);
                    IncrementAction();
                    target = BattleManager.PlayerParty[index];
                }
                else if (BattleManager.PlayerParty.Contains(actor))
                {
                    int index = AcquireValidTarget(BattleManager.EnemyParty);
                    IncrementAction();
                    target = BattleManager.EnemyParty[index];
                }
                if (target != null)
                {
                    BattleStats targetStats;
                    if (stats.TryGetValue(target, out targetStats))
                    {
                        int dmg = 0;
                        // Calculate damage
                        BattleActorInfo attacker;
                        BattleActorInfo defender;
                        if (actorStat.GetVirtue() >= actorStat.GetSpirit())
                        {
                            attacker = new BattleActorInfo(actorStat, actorStat.GetVirtue(), actor.Level);
                            defender = new BattleActorInfo(targetStats, targetStats.GetResolve(), target.Level);
                        }
                        else
                        {
                            attacker = new BattleActorInfo(actorStat, actorStat.GetSpirit(), actor.Level);
                            defender = new BattleActorInfo(targetStats, targetStats.GetSpirit(), target.Level);
                        }
                        IBattleFormula <int> formula = BattleFormulaQueue.Queue.Dequeue();
                        dmg = formula.Generate(attacker, defender, Turn, ActionCount);
                        targetStats.SetHP(targetStats.GetHP() - dmg);
                        Debug.Log(actor.Name + " damages " + target.Name + " for " + dmg + " using " + formula.GetType().Name);
                        IncrementAction();
                    }
                }
            }
            speedCount = actorStat.GetDeft() - 1;

            if (ConditionCheck())
            {
                //Battle complete
                Debug.Log("=== Battle complete!");
                break;
            }
        }
        if (!ConditionResult())
        {
            IncrementTurn();
            BattleFormulaQueue.PopulateQueue();
        }
    }