/// <summary> /// The method to run when this action is being used. /// </summary> /// <param name="target">The target battle driver</param> protected override void Use(BaseBattleDriver target) { foreach (Buff buff in Bravery.buffs) { buff.Apply(target); } }
/// <summary> /// Returns a new instance of a battle action class based on an enum /// </summary> /// <param name="action">The action to get</param> /// <param name="user">The user to initialize it with</param> /// <returns>A new instance of a battle action</returns> public static BattleAction GetBattleAction(ActionClass action, BaseBattleDriver user) { switch (action) { case ActionClass.AOEHeal: return(new AOEHeal(user)); case ActionClass.Bravery: return(new Bravery(user)); case ActionClass.FireMagic: return(new FireMagic(user)); case ActionClass.MajorHeal: return(new MajorHeal(user)); case ActionClass.MinorHeal: return(new MinorHeal(user)); case ActionClass.Smash: return(new Smash(user)); case ActionClass.QuickSlash: return(new QuickSlash(user)); case ActionClass.NoAction: return(new NoAction(user)); default: // Default to smash return(new Smash(user)); } }
/// <summary> /// Spawns an entity based on a prefab with a bonus /// </summary> /// <typeparam name="T">The type of the prefab</typeparam> /// <param name="prefab">The prefab to use</param> /// <param name="bonus1">The first bonus stat</param> /// <param name="bonus2">The second bonus stat</param> /// <returns>The new entity</returns> public static T SpawnEntityWithBonus <T>(T prefab, Stat?bonus1 = Stat.Random, Stat?bonus2 = Stat.Random) where T : BaseDriver { T driver = Instantiate(prefab); BaseBattleDriver battleDriver = driver.battleDriver; if (bonus1 == Stat.Random) { bonus1 = MainGeneral.GetRandomStat(); } if (bonus2 == Stat.Random) { bonus2 = MainGeneral.GetRandomStat(bonus1); } if (bonus1 != null) { battleDriver.SetBaseStat( (Stat)bonus1, battleDriver.GetBaseStat((Stat)bonus1) * BaseBattleDriver.BonusStatMultiplier); } if (bonus2 != null) { battleDriver.SetBaseStat( (Stat)bonus2, battleDriver.GetBaseStat((Stat)bonus2) * BaseBattleDriver.BonusStatMultiplier); } return(driver); }
/// <summary> /// The method to run when this action is being used. /// </summary> /// <param name="target">The target battle driver</param> protected override void Use(BaseBattleDriver target) { if (target.TakingTurn) { target.TakingTurn = false; } }
/// <summary> /// Deal damage respecting the damage formula. /// </summary> /// <param name="target">The defending BattleDriver</param> /// <returns>The amount of damage dealt</returns> public int DealDamage(BaseBattleDriver target) { float damageStat; switch (this.Category) { case ActionCategory.PhysicalAttack: damageStat = this.User.PhysicalDamage; break; case ActionCategory.MagicalAttack: damageStat = this.User.MagicalDamage; break; default: Debug.LogWarning("Attempting to deal damage with BattleAction of category " + this.Category.ToString()); damageStat = 0.0f; break; } int damageValue = (int)Mathf.Max( 0.0f, (BaseBattleDriver.LevelStatOffset + this.User.Level) * this.AttackPower * damageStat / target.Defense); target.CurrentHealth -= damageValue; return(damageValue); }
/// <summary> /// Initializes a new instance of the <see cref="QuickSlash"/> class /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public QuickSlash(BaseBattleDriver user) : base(user) { this.name = "Quick Slash"; this.description = "A fast attack which deals high damage."; this.attackPointCost = 7.0f; this.attackPower = 14.0f; this.category = ActionCategory.PhysicalAttack; this.targetOption = ActionTargetOption.OneOpponent; }
/// <summary> /// Initializes a new instance of the <see cref="Smash"/> class /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public Smash(BaseBattleDriver user) : base(user) { this.name = "Smash"; this.description = "Ram into an enemy to deal some damage."; this.attackPointCost = 4.0f; this.attackPower = 10.0f; this.category = ActionCategory.PhysicalAttack; this.targetOption = ActionTargetOption.OneOpponent; }
/// <summary> /// Initializes a new instance of the <see cref="Bravery"/> class /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public Bravery(BaseBattleDriver user) : base(user) { this.name = "Bravery"; this.description = "Increases Damage and Defense of all allies for 1 turn."; this.attackPointCost = 12.0f; this.attackPower = 0.0f; this.category = ActionCategory.Support; this.targetOption = ActionTargetOption.AllAllies; }
/// <summary> /// Initializes a new instance of the <see cref="_NewAction"/> class /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public _NewAction(BaseBattleDriver user) : base(user) { this.name = "ACTIONNAME"; this.description = "ACTIONDESCRIPTION"; this.attackPointCost = 10.0f; this.attackPower = 10.0f; this.category = ActionCategory.Undefined; this.targetOption = ActionTargetOption.OneOpponent; }
/// <summary> /// Initializes a new instance of the <see cref="NoAction"/> class /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public NoAction(BaseBattleDriver user) : base(user) { this.name = "End Turn"; this.description = "Ends the current turn."; this.attackPointCost = 1.0f; this.attackPower = 0.0f; this.category = ActionCategory.Undefined; this.targetOption = ActionTargetOption.Self; }
/// <summary> /// Initializes a new instance of the <see cref="FireMagic"/> class /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public FireMagic(BaseBattleDriver user) : base(user) { this.name = "Fire Magic"; this.description = "Magic which deals damage to an opponent and has them take damage for a few turns."; this.attackPointCost = 5.0f; this.attackPower = 5.0f; this.category = ActionCategory.MagicalAttack; this.targetOption = ActionTargetOption.OneOpponent; }
/// <summary> /// Finds all fighters with the same tag as <paramref name="leaderBattleDriver"/> /// and adds the ones not participating to <seealso cref="DeactivatableGameObjects"/> /// </summary> /// <param name="leaderBattleDriver">The leader of the bunch</param> /// <returns>A list of <seealso cref="BaseBattleDriver"/>s</returns> private List <BaseBattleDriver> FindFighters(BaseBattleDriver leaderBattleDriver) { // Find all GameObjects with the same tag as the leader GameObject[] allFighters = GameObject.FindGameObjectsWithTag(leaderBattleDriver.tag); List <BaseBattleDriver> listOfFighters = new List <BaseBattleDriver>(); BaseDriver leaderDriver = leaderBattleDriver.GetComponent <BaseDriver>(); // Check each of them foreach (GameObject fighter in allFighters) { BaseDriver driver = fighter.GetComponent <BaseDriver>(); if (driver != null && (driver.Leader == leaderDriver || driver == leaderDriver)) { // Required component; should never be missing listOfFighters.Add(fighter.GetComponent <BaseBattleDriver>()); } else { fighter.SetActive(false); this.DeactivatableGameObjects.Add(fighter); } } // Sort them List <BaseBattleDriver> listOfFightersSorted = new List <BaseBattleDriver>(listOfFighters.Count); for (int i = 0; i < listOfFighters.Count; i++) { foreach (BaseBattleDriver battleDriver in listOfFighters) { BaseDriver driver = battleDriver.entityDriver; int number = 0; while (driver.Following != null) { driver = driver.Following; ++number; if (number > listOfFighters.Count) { throw new RPGException(RPGException.Cause.DriverLoopingFollowing); } } if (number == i) { listOfFightersSorted.Add(battleDriver); } } } return(listOfFightersSorted); }
/// <summary> /// Initializes a new instance of the <see cref="AOEHeal"/> class /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public AOEHeal(BaseBattleDriver user) : base(user) { this.name = "Area Heal"; this.description = "Heals all allies for 25% of their Maximum Health."; // Storing heal-potential (fraction) in attack power. this.attackPower = 0.25f; this.attackPointCost = 10.0f; this.category = ActionCategory.Support; this.targetOption = ActionTargetOption.AllAllies; }
/// <summary> /// Called by Unity to initialize the <seealso cref="BaseDriver"/> whether it is or is not active. /// </summary> protected virtual void Awake() { this.spriteManager = this.GetComponent <SpriteManager>(); this.spriteAnimator = this.GetComponent <SpriteAnimator>(); this.battleDriver = this.GetComponent <BaseBattleDriver>(); this.highlight = this.GetComponent <Highlighter>(); this.rigidbody = this.GetComponent <Rigidbody>(); this.lastVelocity = this.transform.forward; this.battleDriver.enabled = false; }
/// <summary> /// Initializes a new instance of the <see cref="MajorHeal"/> class /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public MajorHeal(BaseBattleDriver user) : base(user) { this.name = "Major Heal"; this.description = "Fully recovers an allies health."; // Storing heal-potential (fraction) in attack power. this.attackPower = 1.00f; this.attackPointCost = 14.0f; this.category = ActionCategory.Support; this.targetOption = ActionTargetOption.OneAlly; }
/// <summary> /// Initializes a new instance of the <see cref="_NewHeal"/> class /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public _NewHeal(BaseBattleDriver user) : base(user) { this.name = "ACTIONNAME"; this.description = "ACTIONDESCRIPTION"; // Storing heal-potential (fraction) in attack power. this.attackPower = 0.25f; this.attackPointCost = 6.0f; this.category = ActionCategory.Support; this.targetOption = ActionTargetOption.OneAlly; }
/// <summary> /// Initializes a new instance of the <see cref="MinorHeal"/> class /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public MinorHeal(BaseBattleDriver user) : base(user) { this.name = "Minor Heal"; this.description = "Heals an ally for 25% of their Maximum Health."; // Storing heal-potential (fraction) in attack power. this.attackPower = 0.25f; this.attackPointCost = 6.0f; this.category = ActionCategory.Support; this.targetOption = ActionTargetOption.OneAlly; }
/// <summary> /// Applies a buff to a battle driver /// </summary> /// <param name="target">The target battle driver</param> public void Apply(BaseBattleDriver target) { this.OnApplication(target); int turnDuration = this.TurnDuration; target.EndTurnActions.Add(delegate { --turnDuration; if (turnDuration <= 0) { this.OnRemoval(target); return(true); } this.OnTurn(target); return(false); }); }
/// <summary> /// Charges through the target. /// </summary> /// <param name="target">The target</param> /// <returns>An enumator</returns> protected IEnumerator DoCharge(BaseBattleDriver target) { this.User.IsWaitingOnAnimation = true; Rigidbody rigidbody = this.User.GetComponent <Rigidbody>(); Vector3 lookAt = target.transform.position - this.User.transform.position; lookAt.Normalize(); lookAt *= this.velocityMultiplier; rigidbody.velocity = lookAt + new Vector3(0.0f, this.yVelocity, 0.0f); Func <bool> wait = delegate { return(rigidbody.velocity.y > 0.0f); }; yield return(new WaitUntil(wait)); yield return(new WaitWhile(wait)); rigidbody.velocity = Vector3.zero; this.User.IsWaitingOnAnimation = false; }
/// <summary> /// Initializes a new instance of the <see cref="ChargeAction"/> class. /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public ChargeAction(BaseBattleDriver user) : base(user) { }
/// <summary> /// The method to run when this action is being used. /// </summary> /// <param name="target">The target battle driver</param> protected override void Use(BaseBattleDriver target) { // Code here }
/// <summary> /// Called when the buff runs out /// </summary> /// <param name="target">The target battle driver</param> protected override void OnRemoval(BaseBattleDriver target) { target.SetStat(this.Stat, target.GetStat(this.Stat) / this.Multiplier); }
/// <summary> /// Initializes a new instance of the <see cref="HealAction"/> class. /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public HealAction(BaseBattleDriver user) : base(user) { }
/// <summary> /// Does a small jump. /// </summary> /// <param name="battleDriver">The entity that needs to jump</param> protected static void DoSmallJump(BaseBattleDriver battleDriver) { battleDriver.GetComponent <Rigidbody>().velocity = new Vector3(0.0f, 0.5f, 0.0f); }
/// <summary> /// The method to run when this action is being used. /// </summary> /// <param name="target">The target battle driver</param> protected override void Use(BaseBattleDriver target) { this.DealDamage(target); this.User.StartCoroutine(this.DoCharge(target)); }
/// <summary> /// The method to run when this action is being used. /// </summary> /// <param name="target">The target battle driver</param> protected override void Use(BaseBattleDriver target) { this.DealDamage(target); new FireDebuff().Apply(target); }
/// <summary> /// The method to run when this action is being used. /// </summary> /// <param name="target">The target battle driver</param> protected override void Use(BaseBattleDriver target) { target.CurrentHealth += (int)(target.MaximumHealth * this.attackPower); HealAction.DoSmallJump(target); }
/// <summary> /// Initializes a new instance of the <see cref="BattleAction"/> class. /// Since this is an abstract class, it only serves as a base. /// </summary> /// <param name="user">The BattleDriver which will use this action</param> public BattleAction(BaseBattleDriver user) { this.User = user; }
/// <summary> /// The method to run on the target when this action is being used. /// </summary> /// <param name="target">The target battle driver</param> protected abstract void Use(BaseBattleDriver target);
/// <summary> /// Called every turn while the buff is applied /// </summary> /// <param name="target">The target battle driver</param> protected override void OnTurn(BaseBattleDriver target) { target.CurrentHealth -= (int)(target.MaximumHealth * FireDebuff.DamagePerTurn); }