/// <summary> /// <para> /// Static-based Prediction Algorithm is an another high abstraction prediction algorithm. /// Unlike the <see cref="LanchesterBasedPrediction(TargetPolicy)"/>, the computation focuses more /// on time-related properties of combat. However, like the mentioned prediction algorithm, it still /// exchanges fine detail for faster computing. Like the <see cref="LanchesterBasedPrediction(TargetPolicy)"/>, /// It does not consider that the Energy decreases over time, and that some skills have cooldown and duration. /// However, it does consider that the damage is not constant by adding noises to the damage such as /// there are times it is the current damage, and sometimes it is more than the current damage. It also considers /// that some units cannot target other units, and considers skills that deals damage/boost damage but not on the /// finest detail. Lastly, it also consider that the dealt damage is reduced by the armor. /// </para> /// <para> /// This method returns a string of survived units from the winning army, but the cost worth of doing /// battle is always relative to the player. As such, if the opposing army won, the cost worth returned /// is negative since it represents as a loss. /// </para> /// </summary> /// <remarks> /// <para> /// While it still looks the army as a whole, it computes more parameters. /// The probable running time is O(4n^2 + 32n) /// </para> /// <para> /// In summary, it is almost like the Lanchester-based prediction where it looks at the army as /// a whole, but also considers the time-related property of combat. Lastly, it also adds noise /// to the damage being dealt to the target. It considers and does not consider the following: /// Considers: /// <list type="bullet"> /// <item>Current and Decreasing Health</item> /// <item>True Current Damage (Current Damage applied with opposing Armor)</item> /// <item>Restrictions in targeting unit</item> /// <item>Skills that deals damage and gives boost to the damage of unit</item> /// <item>Time-related properties to battle</item> /// </list> /// Does not Consider: /// <list type="bullet"> /// <item>Decreasing Energy</item> /// <item>Skills with Cooldown and Duration</item> /// <item>Skills that affects Health/Energy</item> /// <item>AoE Damage / Chaining Damage</item> /// <item>Transforming Units</item> /// <item>Damage with bonus to target type</item> /// </list> /// </para> /// </remarks> /// <param name="target_policy"></param> /// <returns></returns> public Tuple <string, CostWorth> StaticBasedPrediction(TargetPolicy target_policy) { Tuple <string, CostWorth> battle_result = null; try { //Create a copy of the units var owned_units = _owned_units.GetDeepCopy(); var enemy_units = _enemy_units.GetDeepCopy(); //Set the targets for each army //This will get the true damage of unit, and a target to be attacked switch (target_policy) { case TargetPolicy.Random: RandomBasedTargetPolicy(ref owned_units, enemy_units); RandomBasedTargetPolicy(ref enemy_units, owned_units); break; case TargetPolicy.Priority: PriorityBasedTargetPolicy(ref owned_units, enemy_units); PriorityBasedTargetPolicy(ref enemy_units, owned_units); break; case TargetPolicy.Resource: ResourceBasedTargetPolicy(ref owned_units, enemy_units); ResourceBasedTargetPolicy(ref enemy_units, owned_units); break; } //Compute the battle output var combat_result = new StaticCombatResult(owned_units, enemy_units); var combat_time = StaticCombatResult.GetCombatTime(combat_result); //Let both armies attack each other owned_units.DealDamageToTarget(combat_time); enemy_units.DealDamageToTarget(combat_time); //Get the surviving units of the winner var survived_owned_units = owned_units.Where(unit => !unit.IsDefeated).ToArmy(); var survived_enemy_units = enemy_units.Where(unit => !unit.IsDefeated).ToArmy(); //Owned Army Loss if (survived_owned_units.Count() < survived_enemy_units.Count()) { battle_result = new Tuple <string, CostWorth>(survived_enemy_units.ToString(), !survived_enemy_units.GetValueOfArmy()); } //Owned Army Won else if (survived_owned_units.Count() > survived_enemy_units.Count()) { battle_result = new Tuple <string, CostWorth>(survived_owned_units.ToString(), survived_owned_units.GetValueOfArmy()); } //Draw else { battle_result = new Tuple <string, CostWorth>(@"""""", default(CostWorth)); } } catch (ArgumentNullException ex) { Console.WriteLine($@"StaticBasedPrediction() [{target_policy.ToString()}] -> {ex.Message}"); throw new Exception(""); } catch (Exception ex) { Console.WriteLine($@"StaticBasedPrediction() -> {ex.Message}"); battle_result = null; } return(battle_result); }
/// <summary> /// Returns the combat time /// </summary> /// <param name="combat_result"></param> /// <returns></returns> public static int GetCombatTime(StaticCombatResult combat_result) => Convert.ToInt32(Math.Ceiling(combat_result.TimeToKill));