/// <summary> /// Gets the abilities by type /// </summary> /// <returns>The abilities by type.</returns> /// <param name="type">Type.</param> private List <Ability> GetAbilitiesByType(Ability.AbilityType type) { // Create tmp dictionary for filtering by type var tmpAbilityDict = new Dictionary <int, Ability>(); foreach (var ability in _abilities) { if (ability.Value.Type == type) { tmpAbilityDict.Add(ability.Key, ability.Value); } } // Sort by id var sortedList = tmpAbilityDict.Keys.ToList(); sortedList.Sort(); // Create final sorted ability list var abilityList = new List <Ability>(); foreach (var id in sortedList) { abilityList.Add(_abilities [id]); } return(abilityList); }
/* * Set the focus on the enemy or the ally team * and on a single or multi target */ private void SetFocus(Ability.AbilityTarget target, Ability.AbilityType type) { // Wait for player enemy target choice playerUI.SetActive(false); if (_choosedAbility.target == Ability.AbilityTarget.MULTI) { if (_choosedAbility.type == Ability.AbilityType.ATTACK) { _fighters.FindAll(e => e.player != _activeFighter.player && e.dead == false).Select(e => { e.ForceSelect(); return(e); }).ToList(); } else { _fighters.FindAll(e => e.player == _activeFighter.player && e.dead == false).Select(e => { e.ForceSelect(); return(e); }).ToList(); } } else { if (_choosedAbility.type == Ability.AbilityType.ATTACK) { // Set enemies focusable _fighters.FindAll(e => e.player != _activeFighter.player && e.dead == false).Select(e => { e.ChangeFocus(true); return(e); }).ToList(); // Set first ally as focused EventSystem.current.SetSelectedGameObject(_fighters.First(e => e.player != _activeFighter.player && e.dead == false).gameObject); } else { // Set allies focusable _fighters.FindAll(e => e.player == _activeFighter.player && e.dead == false).Select(e => { e.ChangeFocus(true); return(e); }).ToList(); // Set first ally as focused EventSystem.current.SetSelectedGameObject(_fighters.First(e => e.player == _activeFighter.player && e.dead == false).gameObject); } } }
public void AddDamage(PlayerStats attacker, int damage, Ability.AbilityType type) { //Debug.Log(Stats.Health); // reset the damage counter timer everytime I take damage m_RecentDamageTimer = m_TimeForRecentDamage + Time.time; m_RecentDamage += damage; // check if my recent damage is above the threshold if (m_RecentDamage >= m_AmountOfDamageAllowed) { // find a random teleport location and switch my state to teleport there SwitchState(new BossTeleportAIState(this, TeleportLocations[Random.Range(0, 4)])); m_RecentDamage = 0; } m_PlayerDamages[attacker] += damage; m_NeedNewTarget = CheckIfNeedNewTarget(); if (m_NeedNewTarget) { m_CurrentTargetAbilityType = type; } float tenPercentOfMaxHealth = Stats.MaxHealth * 0.1f; float maxHealthMinusTenPercent = Stats.MaxHealth - tenPercentOfMaxHealth; float currentHealthMinusTenPercent = Stats.Health - tenPercentOfMaxHealth; float AbilityTimerCoolDownMultiplier = ((currentHealthMinusTenPercent / maxHealthMinusTenPercent) + 1) / 2f; m_GroundShockCoolDownTime *= AbilityTimerCoolDownMultiplier; m_EnergyMineCoolDownTime *= AbilityTimerCoolDownMultiplier; m_KnockbackCoolDownTime *= AbilityTimerCoolDownMultiplier; }
public Skill(string name, Ability.AbilityType asset, string descr) : this() { this.name = name; this.asset = asset; this.description = descr; }
public Ability GetAbility(Ability.AbilityType type) { if (registry.TryGetValue(type, out AbilitySettings item)) { return(item.ability); } return(null); }
public void NewActivity(Ability.AbilityType activityType, float castTime, int castTimes, float range, bool move) { currentActivityType = activityType; AbilityCastTime = castTime; AbilityCastTimes = castTimes; TargetAbilityRange = range; CanMove = move; TargetGameObject = Hit.collider.gameObject; TargetPosition = new Vector3(Hit.point.x, transform.position.y, Hit.point.z); }
public void SetVars(int damage_, float range, Effect.AbilityEffect effect_, GameObject owner, Ability.AbilityType aType) { damage = damage_; maxRange = range; effect = effect_; _owner = owner; abilityType = aType; startPosition = transform.position; }
public int GetAbilityLevel(Ability.AbilityType type) { if (abilities.TryGetValue(type, out int currentLevel)) { return(currentLevel); } else { return(abilityRegistry.GetAbility(type).initialLevel); } }
//public float m_ExplosionCountdown = 1.0f; //public float m_GracePeriod = 2.0f; public override void Initialize(CharacterStats attacker, Ability.AbilityType type, int abilityDamage, float lifetime) { Attacker = attacker; Type = type; AbilityDamage = abilityDamage; ExplosionDamage += attacker.Damage; m_LifeTime = lifetime + Time.time; //m_ExplosionCountdown = lifetime + Time.time; //m_GracePeriod += Time.time; }
public void ExecuteAbility(string abilityName, Target target) { Ability ability = this.GetAbility(abilityName); Ability.AbilityType abilityType = ability.GetAbilityType(); if (abilityType == Ability.AbilityType.Major) { --this.numMajorAbilities; } if (abilityType == Ability.AbilityType.Minor) { --this.numMinorAbilities; } ability.Execute(target); }
public bool IncreaseAbilityLevel(Ability.AbilityType type) { Ability ability = abilityRegistry.GetAbility(type); int currentLevel; if (!abilities.TryGetValue(type, out currentLevel)) { currentLevel = ability.initialLevel; } if (currentLevel < ability.maximumLevel) { abilities[type] = currentLevel + 1; onAbilityLevelChange?.Invoke(new AbilityLevelChangeArg(gameObject, ability, abilities[type])); return(true); } return(false); }
/// <summary> /// Add the specified ability. /// </summary> /// <param name="ability">Ability.</param> public void Add(Ability ability) { _abilities.Add(ability.Id, ability); // Set ability type flags based on passed in abilities Ability.AbilityType type = ability.Type; if (type == Ability.AbilityType.TALENT) { if (!HasTalent) { HasTalent = true; } } else if (type == Ability.AbilityType.MAGIC) { if (!HasMagic) { HasMagic = true; } } }
/// <summary> /// Plays the attack animations. /// </summary> /// <returns>The attack animations.</returns> /// <param name="attacker">Attacker.</param> /// <param name="direction">Direction.</param> protected IEnumerator PlayAttackAnimations(Unit attacker, Vector3 direction) { Ability.AbilityType abilityType = attacker.Action.Ability.Type; if (abilityType == Ability.AbilityType.ATTACK || attacker.Action.Ability.Id == AbilityConstants.MEASURED_STRIKE) { //determine which way to swing, dependent on the direction the enemy is Unit.TileDirection facing = attacker.GetDirectionToTarget(direction); UnitAnimationController animationController = attacker.GetAnimationController(); switch (facing) { case Unit.TileDirection.NORTH: animationController.AttackNorth(); break; case Unit.TileDirection.EAST: animationController.AttackEast(); break; case Unit.TileDirection.SOUTH: animationController.AttackSouth(); break; case Unit.TileDirection.WEST: animationController.AttackWest(); break; } } else if (attacker.Action.Ability.Id == AbilityConstants.WHIRLWIND_SLASH) { UnitAnimationController animationController = attacker.GetAnimationController(); animationController.WhirlwindSlash(); } else if (attacker.Action.Ability.Id == AbilityConstants.LEAPING_SLICE) { UnitAnimationController animationController = attacker.GetAnimationController(); animationController.LeapingSlice(); } yield return(null); }
public bool IsAbilityExecutable(string abilityName) { Ability ability = this.GetAbility(abilityName); bool result = false; Ability.AbilityType abilityType = ability.GetAbilityType(); if (ability.uses > 0) { if (abilityType == Ability.AbilityType.Major && this.numMajorAbilities > 0) { result = true; } if (abilityType == Ability.AbilityType.Minor && this.numMinorAbilities > 0) { result = true; } } return(result); }
public override void Initialize(CharacterStats attacker, Ability.AbilityType type, int abilityDamage, float lifetime) { base.Initialize(attacker, type, abilityDamage, lifetime); }
public Skill(string name, Ability.AbilityType asset, string descr) : this() { this.name = name; this.asset = asset; this.description = descr; }
public int GetAbilityValueInt(Ability.AbilityType type) { return(Mathf.FloorToInt(GetAbilityValue(type))); }
/// <summary> /// Performs the action of the attacker against their targets. /// </summary> /// <returns>The action.</returns> /// <param name="attacker">Attacker.</param> protected IEnumerator PerformAbilityAction(Unit attacker) { if (attacker.Action.Item != null) { // Lower music so you can hear ability SFX yield return(StartCoroutine(controller.MusicController.LowerCombatMusic())); // Show name of ability being used attacker.TileHighlighter.RemoveHighlightedTiles(); Item item = attacker.Action.Item; controller.ActionController.Activate(item.Name); yield return(new WaitForSeconds(0.5f)); // Spawn VFX on all targets List <Unit> targets = attacker.Action.Targets; List <GameObject> vfxGameObjects = ApplyVFXToTargets(item.VFXPath, targets); // Iterate over all effects, apply them, and if there is something to display, show it PopupTextController.Initialize(attacker.GetCanvas()); List <Effect> effects = ConsumableEffectCalculator.GetConsumableEffects(item); yield return(StartCoroutine(ApplyEffects(targets, effects))); attacker.UpdateHealthbar(); // Show XP floaty text ShowXPFloatyText(new ExperienceManager().AwardConsumableExperience(attacker), attacker); yield return(new WaitForSeconds(1.0f)); // Destroy VFX's DestroyVFX(vfxGameObjects); // Remove name of used ability controller.ActionController.Deactivate(); // Bring music back up to normal volume yield return(StartCoroutine(controller.MusicController.RaiseCombatMusic())); controller.ChangeState <TurnOverState> (); } // If the ability takes more than x turns, defer the ability action else if (!attacker.HasDeferredAbility && attacker.Action.Ability.Turns > 1) { attacker.HasDeferredAbility = true; yield return(null); controller.ChangeState <TurnOverState> (); } else { // Reset bool flags depending on if a deferred attack is being executed if (attacker.HasDeferredAbility) { attacker.HasDeferredAbility = false; attacker.HasExecutedDeferredAbility = true; } // Lower music so you can hear ability SFX yield return(StartCoroutine(controller.MusicController.LowerCombatMusic())); // Show name of ability being used attacker.TileHighlighter.RemoveHighlightedTiles(); Ability ability = attacker.Action.Ability; controller.ActionController.Activate(ability.Name); yield return(new WaitForSeconds(0.5f)); // Spawn VFX on all targets List <Unit> targets = attacker.Action.Targets; List <GameObject> vfxGameObjects = ApplyVFXToTargets(ability.VFXPath, targets); // Start Combat Combat combat = new Combat(controller.HighlightedUnit); combat.Begin(); // Play weapon sound effect Ability.AbilityType abilityType = attacker.Action.Ability.Type; if (abilityType == Ability.AbilityType.ATTACK || abilityType == Ability.AbilityType.TALENT) { attacker.PlayWeaponSound(); } // Show target(s) being damaged ShowDamagedColorOnTargets(true, targets); // Play animations yield return(StartCoroutine(PlayAttackAnimations(attacker, targets [0].Tile))); // Iterate over all effects, apply them, and if there is something to display, show it PopupTextController.Initialize(attacker.GetCanvas()); yield return(StartCoroutine(ApplyEffectsByUnit(attacker.Action.GetEffectsByUnit()))); yield return(new WaitForSeconds(1.0f)); // Stop showing target(s) being damaged ShowDamagedColorOnTargets(false, targets); // Show XP floaty text ShowXPFloatyText(combat.GetAwardedExperience(), attacker); yield return(new WaitForSeconds(1.0f)); // Destroy VFX's DestroyVFX(vfxGameObjects); // Remove name of used ability controller.ActionController.Deactivate(); // Bring music back up to normal volume yield return(StartCoroutine(controller.MusicController.RaiseCombatMusic())); controller.ChangeState <TurnOverState> (); } }
/// <summary> /// Internal Function. Finds the correct "Equipped Abilities" slot to put the newly equipped ability in, /// inserts it and removes what was there before. /// <para> Hybrid abilities can be equipped in either slot of their category, thus the function can be told which of the two slots the /// player wants to equip the ability to. </para> /// </summary> /// <param name="equippedAbility">The ability to be equipped.</param> /// <param name="equippedAbilityType">Which slot the ability should be equipped in. Either Primary, Secondary or Synnergised.</param> void ProcessNewAbility(Ability newAbility, Ability.AbilityType newAbilityType) { // first we check if the new ability is a primary or secondary ability. if (newAbilityType == Ability.AbilityType.Primary) // deals with all the primary abilities { // Then we must check the ability's category - this tells us where to put it in the UI and arrays. switch (newAbility.abilityCategory) { case Ability.AbilityCategory.Jump: // This ability is a Primary Jump { AddAbility(newAbility, (int)AbilityNameIndex.PrimaryJump); } break; case Ability.AbilityCategory.Melee: // This ability is a Primary Attack { AddAbility(newAbility, (int)AbilityNameIndex.PrimaryAttack); } break; case Ability.AbilityCategory.Defense: // This ability is a Primary Defense { AddAbility(newAbility, (int)AbilityNameIndex.PrimaryDefense); } break; case Ability.AbilityCategory.Ranged: // This ability is a Primary Ranged { AddAbility(newAbility, (int)AbilityNameIndex.PrimaryRanged); } break; } } else if (newAbilityType == Ability.AbilityType.Secondary) // Deals with all the secondary abilities { // We must check the ability's category - this tells us where to put it in the UI and arrays. switch (newAbility.abilityCategory) { case Ability.AbilityCategory.Jump: // This ability is a Secondary Jump { AddAbility(newAbility, (int)AbilityNameIndex.SecondaryJump); } break; case Ability.AbilityCategory.Melee: // This ability is a Secondary Attack { AddAbility(newAbility, (int)AbilityNameIndex.SecondaryAttack); } break; case Ability.AbilityCategory.Defense: // This ability is a Secondary Defense { AddAbility(newAbility, (int)AbilityNameIndex.SecondaryDefense); } break; case Ability.AbilityCategory.Ranged: // This ability is a Secondary Ranged { AddAbility(newAbility, (int)AbilityNameIndex.SecondaryRanged); } break; } } else if (newAbilityType == Ability.AbilityType.Synergised) // Ability is a synnergised ability - arising from special { // ability combinations. Will implement later. Debug.LogWarning("Synnergy Functionality not implemented yet." + " Cannot equip " + newAbility.name + "."); } else if (newAbilityType == Ability.AbilityType.Hybrid) // Ability entered was a Hybrid ability - which shouldn't have happened. { // The user must choose to treat this as either primary or secondary. Debug.LogWarning("Player choice for hybrid's usage not defined. Please choose either primary or secondary type" + " to equip " + newAbility.name + "."); return; } // I would have used nested switch statements, but that was far harder to read than this - so for the // sake of understanding I used if statements. }
/// <summary> /// Adds this ability to the correct 'Equipped Abilities' slot and unequips what was initially there. /// <para>Use this overloaded version for Hybrid abilities, as they require the user to choose whether they want to use the /// ability as a primary or secondary ability.</para> /// </summary> /// <param name="newAbility">Ability to be equipped.</param> /// <param name="newAbilityType">The type of ability the user wants to treat this as. Either Primary or Secondary.</param> public void EquipAbility(Ability newAbility, Ability.AbilityType newAbilityType) { ProcessNewAbility(newAbility, newAbilityType); }
public float GetAbilityValue(Ability.AbilityType type) { return(abilityRegistry.GetAbility(type).ValueAtLevel(GetAbilityLevel(type))); }