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));
}
