protected override void DoAction(BossPartStateController controller) { BossPart bossPart = controller.bossPart; Ability ability = AbilityUtils.FindAbilityByName( "Boss_MiniDebuffAoeAbility", bossPart.GetAbilityAgent().abilitiesMulti ); if (!ability || !(ability is AoeAbility)) { return; } AoeAbility aoeAbility = (AoeAbility)ability; var reachabeEnemies = WorkManager.FindReachableObjects(controller.nearbyEnemies, bossPart.transform.position, ability.range); // wait till at least 2 targets are reachable if (ability != null && ability.IsReady() && reachabeEnemies.Count > 1) { var abilityTarget = AoeUtils.GetAoeTargetPosition( ability.range, reachabeEnemies, bossPart.GetPlayer() ); bossPart.UseAbility(abilityTarget, aoeAbility); } }
new void Awake() { base.Awake(); gameManager = GameObject.FindGameObjectWithTag("GameManager").GetComponent <Manager_Game>(); abilityType = AbilityType.Bombs; InitCooldown(); stacks = gameRules.ABLY_bombsMaxAmmo; deltaDurations = AbilityUtils.GetDeltaDurations(abilityType); lockOnRemaining = gameRules.ABLY_bombsLockOnTime; mask = gameRules.collisionLayerMask; displayInfo.stacks = stacks; if (stacks <= 0) { displayInfo.displayInactive = true; } else { displayInfo.displayInactive = false; } displayInfo.displayStacks = true; }
public void CoolDown() { for (int i = 0; i < abilityLength; i++) { if (ability[i] != null) { ability[i].AbilityCoolDown.CoolDown(); if (!ability [i].AbilityCoolDown.CanUse) { int j = i + 1; Animator anim = GameObject.Find("Ability" + j).GetComponent <Animator> (); if (!anim.GetBool("isInCooldown")) { anim.SetBool("isInCooldown", true); anim.speed = (17.0f / 60) / AbilityUtils.getAbilityCooldown(ability [i]); } } else { int j = i + 1; Animator anim = GameObject.Find("Ability" + j).GetComponent <Animator> (); anim.SetBool("isInCooldown", false); } } } }
// Set what image is displayed for each ability slot public void SetAbilityIconsAndInfo(AbilityType[] abilities) { if (abilities.Length == 0) { ability1Bkg.gameObject.SetActive(false); ability2Bkg.gameObject.SetActive(false); } else if (abilities.Length == 1) { ability1Bkg.gameObject.SetActive(true); ability1Icon.sprite = AbilityUtils.GetDisplayIcon(abilities[0]); ability1Bkg.GetComponent <UI_TooltipSource>().SetText(AbilityUtils.GetDisplayName(abilities[0]) + "\n" + AbilityUtils.GetDisplayDesc(abilities[0])); ability2Bkg.gameObject.SetActive(false); } else if (abilities.Length == 2) { ability1Bkg.gameObject.SetActive(true); ability1Icon.sprite = AbilityUtils.GetDisplayIcon(abilities[0]); ability1Bkg.GetComponent <UI_TooltipSource>().SetText(AbilityUtils.GetDisplayName(abilities[0]) + "\n" + AbilityUtils.GetDisplayDesc(abilities[0])); ability2Bkg.gameObject.SetActive(true); ability2Icon.sprite = AbilityUtils.GetDisplayIcon(abilities[1]); ability2Bkg.GetComponent <UI_TooltipSource>().SetText(AbilityUtils.GetDisplayName(abilities[1]) + "\n" + AbilityUtils.GetDisplayDesc(abilities[1])); } }
public bool IsValid(ActionContext context) { var action = context.BattleAbility; var memory = context.MemoryAPI; return(AbilityUtils.IsRecastable(memory, action.Ability)); }
protected override void ChooseAbilityToUse(UnitStateController controller) { Unit unit = controller.unit; Ability ability = AbilityUtils.FindAbilityByName("CCEnemySleepMultiAbility", unit.GetAbilityAgent().abilitiesMulti); // TODO: add logic on when to use Sleep Multi. }
private void Awake() { targetControllerTypes = new List<Type>(); foreach (string ability in abilities) { targetControllerTypes.Add(AbilityUtils.GetTargetingControllerType(ability)); abilityCooldowns.Add(0); } // throw new NotImplementedException(); }
public void IsRecastableWhenNotOnRecast(AbilityType abilityType) { ability.AbilityType = abilityType; var memoryApi = new FakeMemoryAPI(); memoryApi.Timer = new FakeTimer(); var result = AbilityUtils.IsRecastable(memoryApi, ability); Assert.True(result); }
new void Awake() { base.Awake(); abilityType = AbilityType.ArmorDrain; InitCooldown(); energy = 1; deltaDurations = AbilityUtils.GetDeltaDurations(abilityType); displayInfo.displayFill = true; }
new void Awake() { base.Awake(); abilityType = AbilityType.SelfDestruct; InitCooldown(); energy = 1; deltaDurations = AbilityUtils.GetDeltaDurations(AbilityType.SelfDestruct); displayInfo.displayFill = true; }
public void NotRecastableWhenOnRecast(AbilityType abilityType) { ability.AbilityType = abilityType; var memoryApi = new FakeMemoryAPI(); memoryApi.Timer = new FakeTimer() { ActionRecast = 1 }; var result = AbilityUtils.IsRecastable(memoryApi, ability); Assert.False(result); }
protected override void ChooseAbilityToUse(UnitStateController controller) { Unit unit = controller.unit; Ability ability = AbilityUtils.FindAbilityByName("DBEnemyDotAbilityMulti", unit.GetAbilityAgent().abilitiesMulti); var reachabeEnemies = WorkManager.FindReachableObjects(controller.nearbyEnemies, unit.transform.position, ability.range); // wait till at least 2 targets are reachable if (ability != null && ability.IsReady() && reachabeEnemies.Count > 1) { controller.abilityToUse = ability; } }
protected override void ChooseAbilityToUse(UnitStateController controller) { Unit unit = controller.unit; Ability ability = AbilityUtils.FindAbilityByName("CCEnemySilenceAbility", unit.GetAbilityAgent().abilities); var reachabeEnemies = WorkManager.FindReachableObjects(controller.nearbyEnemies, unit.transform.position, ability.range); if (ability != null && ability.IsReady() && reachabeEnemies.Count > 0) { controller.enemyAbilityTarget = WorkManager.FindMostDamagingObjectInList(reachabeEnemies); controller.abilityToUse = ability; } }
// Clear secondary image from the specified ability slot public void ClearAbilityIconB(int index) { ResetIconBTransform(index); if (index == 0) { ability1IconB.sprite = AbilityUtils.GetDisplayIcon(AbilityType.Default); // This ability type has an empty icon ability1IconBstate = 0; // Reset anim state } else { ability2IconB.sprite = AbilityUtils.GetDisplayIcon(AbilityType.Default); // This ability type has an empty icon ability2IconBstate = 0; // Reset anim state } }
void Update() { timeSinceCreated += Time.deltaTime; if (timeSinceCreated > delay) { var nearbyObjects = WorkManager.FindNearbyObjects(transform.position, transform.localScale.x / 2); HandleEffect(nearbyObjects); AbilityUtils.PlayAbilityVfx(vfxName, transform.position, transform.localScale, transform.rotation); // destroy the area of effect Destroy(gameObject); } }
new void Awake() { base.Awake(); abilityType = AbilityType.Radar; InitCooldown(); energy = 1; deltaDurations = AbilityUtils.GetDeltaDurations(abilityType); displayInfo.displayFill = true; unitsThisPulse = new List <Unit>(); ghostsThisPulse = new List <GameObject>(); }
new void Awake() { base.Awake(); abilityType = AbilityType.IonMissile; InitCooldown(); stacks = gameRules.ABLY_ionMissileMaxAmmo; deltaDurations = AbilityUtils.GetDeltaDurations(abilityType); mask = gameRules.collisionLayerMask; displayInfo.stacks = stacks; displayInfo.displayStacks = true; displayInfo.displayFill = true; }
public override void Run(IGameContext context) { if (context.API.Player.Status.Equals(Status.Fighting)) { return; } var trusts = context.Config.BattleLists["Trusts"].Actions.Where(t => t.IsEnabled); foreach (var trust in trusts) { if (TrustNeedsSummoning(context, trust) && AbilityUtils.IsRecastable(context.API, trust)) { context.Memory.Executor.UseActions(new[] { trust }); } } }
protected override void DoAction(BossPartStateController controller) { BossPart bossPart = controller.bossPart; Ability ability = AbilityUtils.FindAbilityByName( "Boss_AttackDownAbilityMulti", bossPart.GetAbilityAgent().abilitiesMulti ); var reachabeEnemies = WorkManager.FindReachableObjects(controller.nearbyEnemies, bossPart.transform.position, ability.range); // wait till at least 2 targets are reachable if (ability != null && ability.IsReady() && reachabeEnemies.Count > 1) { bossPart.UseAbility(reachabeEnemies, ability); } }
public override void Run() { if (EliteApi.Player.Status.Equals(Status.Fighting)) { return; } var trusts = Config.Instance.BattleLists["Trusts"].Actions.Where(t => t.IsEnabled); foreach (var trust in trusts) { if (TrustNeedsSummoning(trust) && AbilityUtils.IsRecastable(EliteApi, trust.Ability)) { Executor.UseActions(new[] { trust }); } } }
// ———————————————— UI Block ———————————————— // /// <summary> /// /// </summary> /// <param name="abilityBtnList"></param> public void UpdateAbilityIconsUI(List <GameObject> abilityBtnList) { for (int i = 0; i < abilityBtnList.Count; i++) { if (i + 1 < characterDataComponent.abilities.Count) { abilityBtnList[i].SetActive(true); abilityBtnList[i].GetComponent <Image>().sprite = Resources.Load(AbilityUtils.GetAbilityIcon(characterDataComponent.abilities[i + 1]), typeof(Sprite)) as Sprite; } else { abilityBtnList[i].SetActive(false); } } }
private void LeftMouseClick() { if (hud.CursorInBounds()) { GameObject hitObject = FindHitObject(); Vector3 hitPoint = FindHitPoint(); if (hitObject && hitPoint != ResourceManager.InvalidPosition) { if (!WorkManager.ObjectIsGround(hitObject)) { if (!hitObject.transform.parent) { return; } Unit unitToSelect = hitObject.transform.parent.GetComponent <Unit>(); if (unitToSelect) { if (player.selectedAllyTargettingAbility != null) { AbilityUtils.ApplyAllyAbilityToTarget(unitToSelect, player); } else if (Input.GetButton(InputNames.SELECTION_MODIFIER) || Gamepad.GetButton(InputNames.SELECTION_MODIFIER)) { UnitSelectionManager.HandleUnitSelectionWithModifierPress(unitToSelect, player, hud); } else { UnitSelectionManager.HandleUnitSelection(unitToSelect, player, mainCamera, hud); } } } else if (player.SelectedObject) { player.SelectedObject.SetSelection(false, hud.GetPlayingArea()); player.SelectedObject = null; player.selectedObjects .Where(p => p != null) .ToList() .ForEach(p => p.SetSelection(false, hud.GetPlayingArea())); player.selectedObjects = new List <WorldObject>(); } } } }
protected override void ChooseAbilityToUse(UnitStateController controller) { Unit unit = controller.unit; Ability ability = AbilityUtils.FindAbilityByName("DBEnemyMiniDebuffAoeAbility", unit.GetAbilityAgent().abilitiesMulti); var reachabeEnemies = WorkManager.FindReachableObjects(controller.nearbyEnemies, unit.transform.position, ability.range); if (ability != null && ability.IsReady() && reachabeEnemies.Count > 0) { var abilityTargets = reachabeEnemies; controller.aoeAbilityTarget = AoeUtils.GetAoeTargetPosition( ability.range, abilityTargets.ToList(), unit.GetPlayer() ); controller.abilityToUse = ability; } }
// Set secondary image which is overlayed over the specified ability slot and set how it should be animated /// <summary> /// 0 = no behaviour, 1 = rotate clockwise, 2 = rotate counterclockwise slowly /// </summary> /// <param name="index"></param> /// <param name="ability"></param> /// <param name="animState"></param> public void SetAbilityIconB(int index, AbilityType ability, int animState) { // If it is any state which should not rotate, reset rotation if (animState == 0) { ResetIconBTransform(index); } if (index == 0) { ability1IconB.sprite = AbilityUtils.GetDisplayIconB(ability); ability1IconBstate = animState; } else { ability2IconB.sprite = AbilityUtils.GetDisplayIconB(ability); ability2IconBstate = animState; } }
public void DrawAbilities(Ability[] abilities, Ability[] multiAbilities, bool isInMultiMode, Ability pendingAllyTargetingAbility) { Ability[] abilitiesToDraw = isInMultiMode ? multiAbilities : abilities; for (int i = 0; i < abilitiesToDraw.Length; i++) { if (AbilitySlots.Count > i) { AbilitySlots[i].Image.sprite = abilities[i].icon; float cooldownRation = AbilityUtils.GetAbilitySlotCooldownRation(abilities, multiAbilities, i); bool abilityIsWaitingForTargetSelection = abilitiesToDraw[i] && pendingAllyTargetingAbility && pendingAllyTargetingAbility.name == abilitiesToDraw[i].name; AbilitySlots[i].Frame.color = new Color( AbilitySlots[i].Frame.color.r, AbilitySlots[i].Frame.color.g, AbilitySlots[i].Frame.color.b, abilityIsWaitingForTargetSelection ? 0.5f : 0 ); AbilitySlots[i].Name.text = abilitiesToDraw[i].abilityName; AbilitySlots[i].Name.enabled = false; AbilitySlots[i].Shade.sizeDelta = new Vector2( -(cooldownRation) * SLOT_WIDTH, AbilitySlots[i].Shade.sizeDelta.y ); AbilitySlots[i].Shade.anchoredPosition = new Vector2( -SLOT_WIDTH / 2 + (1 - cooldownRation) * SLOT_WIDTH / 2, AbilitySlots[i].Shade.anchoredPosition.y ); } } HideEmptySlots(abilitiesToDraw); }
protected override void DoAction(UnitStateController controller) { Unit unit = controller.unit; EnemyStateController enemyStateController = (EnemyStateController)controller; if (!enemyStateController.abilityToUse && enemyStateController.IsReadyToChooseAbility()) { Ability ability = AbilityUtils.ChooseRandomReadyAbility(unit.GetAbilityAgent().abilities); if (ability != null) { if (ability is AoeAbility) { controller.aoeAbilityTarget = controller.chaseTarget.transform.position; } controller.abilityToUse = ability; enemyStateController.ResetAbilityChoiceTimer(); } } }
// ———————————————— Swapping targeting Controller Block ———————————————— // public override void SwapTargeting(int index) { if (index >= characterDataComponent.targetControllerTypes.Count) { Debug.Log("Index is out of targeting controllers array"); return; } if (characterDataComponent.ap - AbilityUtils.GetAbilityCost(characterDataComponent.abilities[index])[0] >= 0 && characterDataComponent.ep - AbilityUtils.GetAbilityCost(characterDataComponent.abilities[index])[1] >= 0) { currentTargetingController.EndTargeting(); Destroy(currentTargetingController); currentTargetingController = (TargetingController)gameObject.AddComponent(characterDataComponent.targetControllerTypes[index]); currentTargetingController.Construct(battleManager, map, this); } else { Debug.Log("No enough resources!"); } }
protected override void DoAction(BossPartStateController controller) { BossPart bossPart = controller.bossPart; Ability ability = AbilityUtils.FindAbilityByName( "Boss_HealingAbility", bossPart.GetAbilityAgent().abilities ); var reachabeAllies = WorkManager.FindReachableObjects(controller.nearbyAllies, bossPart.transform.position, ability.range); var damagedMajorAllies = reachabeAllies .Where(p => p.hitPoints < p.maxHitPoints && (!(p is Unit) || ((Unit)p).IsMajor()) ) .ToList(); // wait till at least 2 targets are reachable if (ability != null && ability.IsReady() && damagedMajorAllies.Count > 0) { var mostDamagedAlliesHP = damagedMajorAllies.Min(p => p.hitPoints); var mostDamagedAllies = damagedMajorAllies.Find(p => p.hitPoints == mostDamagedAlliesHP); bossPart.UseAbility(mostDamagedAllies, ability); } }
void UseAbility(int index) { //return; if (!HasSelection()) { return; } // If we are dealing with a mixed group of units, don't use abilities EntityType type = EntityType.Default; foreach (Entity e in selection) { // TODO: Check by abilities rather than types if (type == EntityType.Default) { type = e.Type; } else if (e.Type != type) { return; } /* * if (IsUnit(e)) * { * Unit unit = (Unit)e; * if (type == EntityType.Default) * type = unit.type; * else if (unit.type != type) * return; * } */ } foreach (Entity e in selection) { if (IsUnit(e)) { Unit unit = (Unit)e; // Don't have that many abilities if (unit.abilities.Count < index + 1) { return; } //AbilityOld current = unit.abilities[index]; Ability current = unit.abilities[index]; if (AbilityUtils.GetTargetRequirement(current.GetAbilityType()) == 0) // Targets nothing { unit.OrderAbility(index, null); } else if (AbilityUtils.GetTargetRequirement(current.GetAbilityType()) == 1) // Targets a unit { Entity ent = GetEntityFromHit(RaycastFromCursor(0)); // Treat invisible entities as if they don't exist // TODO: Is it visible ON THE SERVER? if (ent) { ent = ent.VisibleBy(team) ? ent : null; } if (ent && IsUnit(ent)) { AbilityTarget targ = new AbilityTarget((Unit)ent); unit.OrderAbility(index, targ); } } else if (AbilityUtils.GetTargetRequirement(current.GetAbilityType()) == 2) // Targets a position { RaycastHit hit = RaycastFromCursor(1); if (hit.collider) { AbilityTarget targ = new AbilityTarget(hit.point); unit.OrderAbility(index, targ); } } } //if IsUnit } //foreach } //UseAbility()
private bool VerifySut(int recastTime = 0) { MockEliteAPI.Timer.RecastTime = recastTime; return(AbilityUtils.IsRecastable(MockEliteAPI.AsMemoryApi(), _ability)); }