IEnumerator SelectAbility()
{
int potentialDamage = 0;
AbilitySelected = null;
AbilityTarget = null;
PlayerControlledBoardUnit newTarget = null;
foreach (AbilityDescription ability in currentUnit.AbilityActivator.ListOfAbilities) //Find the most damage we can do
{
if (ability.AbilityTargetType == AbilityDescription.TargetType.TargetEnemy)
{
int newPotentialDamage = CheckPotentialDamage(ability, ref newTarget);
if (newPotentialDamage > potentialDamage)
{
AbilityTarget = newTarget;
AbilitySelected = ability;
}
}
}
if (AbilitySelected == null || AbilityTarget == null) //No ability to use
{
EndTurn();
}
else
{
StartCoroutine("TargetAbility");
}
yield return(null);
}
public void FinishAbility()
{
BoardManager.instance.FinishAbility();
TemplateManager.instance.FinishAbility();
AbilityInProgress = null;
targetHexagon = null;
}
public AskToPerformAction(AbilityDescription description, ActionInfo actionInfo, AbilityPart afterAction = null
)
{
Description = description;
ActionInfo = actionInfo;
AfterAction = afterAction;
}
public AskAquireLockAction(AbilityDescription description, Func <GenericShip> targetShip, Func <string> showMessage, AbilityPart action)
{
Description = description;
GetTargetShip = targetShip;
GetMessage = showMessage;
Action = action;
}
/// <summary>
/// State called when selecting what kind of attack to use
/// </summary>
void StateSelectAttack()
{
if (Input.GetButtonDown("Cancel") || Input.GetKeyDown(KeyCode.Escape))
{
EnterStateEndOfTurn();
}
if (!CurrentlySelectedUnit.CanCastAbility()) //if we are silenced or something, we cant select an ability
{
return;
}
if (Input.GetButtonDown("Ability1")) //Choose ability 1
{
if ((currentAbility = CurrentlySelectedUnit.AbilityActivator.ActivateAbility(0)) != null)
{
CombatUIManager.instance.PressButton(0, true);
EnterStateTargetAttack();
}
else
{
CombatUIManager.instance.PressButton(0, false);
}
}
else if (Input.GetButtonDown("Ability2")) //Choose ability 2
{
if ((currentAbility = CurrentlySelectedUnit.AbilityActivator.ActivateAbility(1)) != null)
{
CombatUIManager.instance.PressButton(1, true);
EnterStateTargetAttack();
}
else
{
CombatUIManager.instance.PressButton(1, false);
}
}
else if (Input.GetButtonDown("Ability3")) //Choose ability 3
{
if ((currentAbility = CurrentlySelectedUnit.AbilityActivator.ActivateAbility(2)) != null)
{
CombatUIManager.instance.PressButton(2, true);
EnterStateTargetAttack();
}
else
{
CombatUIManager.instance.PressButton(2, false);
}
}
else if (Input.GetButtonDown("Ability4")) //Choose ability 4
{
if ((currentAbility = CurrentlySelectedUnit.AbilityActivator.ActivateAbility(3)) != null)
{
CombatUIManager.instance.PressButton(3, true);
EnterStateTargetAttack();
}
else
{
CombatUIManager.instance.PressButton(3, false);
}
}
}
public SelectShipAction(AbilityDescription abilityDescription, SelectShipFilter filter, AbilityPart action, AiSelectShipPlan aiSelectShipPlan)
{
AbilityDescription = abilityDescription;
Filter = filter;
Action = action;
AiSelectShipPlan = aiSelectShipPlan;
ShowSkipButton = true;
}
/// <summary>
/// Highlights hexagons for an ability
/// </summary>
public void HighlightAbility(Hexagon currentHexagon, AbilityDescription ability, bool TemplateUse = false)
{
int range = ability.castRange;
if (CombatManager.instance.CurrentlySelectedUnit.isEnfeebled)
{
range = Mathf.RoundToInt(ability.castRange * .5f);
}
HighlightLOSNeighbors(currentHexagon, range, ability.AbilityTargetType, TemplateUse);
}
/// <summary>
/// Adds a new ability to the list of abilities
/// </summary>
public void AddNewAbility()
{
if (newAbility == null || ListOfAbilities.Contains(newAbility))
{
newAbility = null;
return;
}
ListOfAbilities.Add(newAbility);
newAbility = null;
}
public void SetAbilities(PlayerControlledBoardUnit u)
{
for (int i = 0; i < u.AbilityActivator.ListOfAbilities.Count; i++)
{
AbilityDescription a = u.AbilityActivator.ListOfAbilities [i];
icons[i].SetIcon(a.AbilityIcon);
icons[i].SetCooldown(a.Cooldown, a.currentCooldown);
icons[i].gameObject.SetActive(true);
}
}
/// <summary>
/// Starts highlighting and using a template for an ability
/// </summary>
public void StartHighlighting(BoardUnit u, AbilityDescription a)
{
CurrentTargets.Clear();
template = templates [(int)a.Template].GetComponentInChildren <Template> ();
TemplateInUse = true;
TemplateTargetType = a.TemplateType;
CurrentUnit = u;
template.Enable();
template.SetScale(a.TemplateSize, a.castRange);
CurrentTargets = template.CurrentHighlight;
}
public EachShipCanDoAction(
Action <GenericShip, Action> eachShipAction,
Action onFinish = null,
ConditionsBlock conditions = null,
AbilityDescription description = null)
{
EachShipAction = eachShipAction;
OnFinish = onFinish ?? Triggers.FinishTrigger;
Conditions = conditions;
AbilityDescription = description;
}
static void Init()
{
// AbilityWindow window = (AbilityWindow)EditorWindow.GetWindow (typeof (AbilityWindow));
// window.Show();
Debug.Log("Created new ability to Path: \"BattleBots/Resources/Abilities/NewAbility.asset\"");
AbilityDescription ab = ScriptableObject.CreateInstance <AbilityDescription>();
AssetDatabase.CreateAsset(ab, @"Assets/BattleBots/Resources/Abilities/NewAbility.asset");
AssetDatabase.SaveAssets();
EditorUtility.FocusProjectWindow();
Selection.activeObject = ab;
}
public AskToUseAbilityAction
(
AbilityDescription description,
AbilityPart onYes,
AbilityPart onNo = null,
Func <bool> aiUseByDefault = null
)
{
Description = description;
OnYes = onYes;
OnNo = onNo;
AiUseByDefault = aiUseByDefault ?? delegate { return(false); };
}
public AskToRotateShipAction
(
AbilityDescription description,
bool rotate90allowed = true,
bool rotate180allowed = true,
bool rotate0allowed = false,
AbilityPart afterAction = null
)
{
Description = description;
Rotate90Allowed = rotate90allowed;
Rotate180Allowed = rotate180allowed;
Rotate0Allowed = rotate0allowed;
AfterAction = afterAction;
}
/// <summary>
/// Starts the turn for a unit
/// </summary>
void StartTurn(PlayerControlledBoardUnit nextUnit)
{
CurrentlySelectedUnit = nextUnit as PlayerControlledBoardUnit;
CombatUIManager.instance.SelectCharacter(nextUnit.transform);
BoardManager.instance.StartTurn();
CurrentlySelectedUnit.StartTurn();
currentAbility = null;
if (!CurrentlySelectedUnit.CanTakeTurn())
{
EnterStateEndOfTurn();
}
else
{
EnterStateMovementSelection();
}
}
public void ReceiveAbilityHit(AbilityDescription a, List <AbilityModifier> mods)
{
foreach (StatusEffect e in a.buffs)
{
if (((BuffEffect)e).BuffType == BuffEffect.Buff.ApplyForceField)
{
ForceFielded = true;
}
e.HexDuration = a.HexDuration;
HexEffects.Add(e);
}
foreach (StatusEffect e in a.debuffs)
{
e.HexDuration = a.HexDuration;
HexEffects.Add(e);
}
}
/// <summary>
/// Checks the ability exists in the AssetDatabase
/// </summary>
string CheckAbilityExists(string name)
{
AbilityDescription _exists = (AbilityDescription)AssetDatabase.
LoadAssetAtPath("Assets/BattleBots/Resources/Abilities/" + name + ".asset", typeof(AbilityDescription));
if (_exists != null)
{
return(_exists.name);
}
else
{
if (name.Length > 0 && !name.EndsWith(" Not Found"))
{
return(name + " Not Found");
}
else
{
return(name);
}
}
}
/// <summary>
/// Check how much damage an ability can do
/// </summary>
public int CheckPotentialDamage(AbilityDescription ability, ref PlayerControlledBoardUnit a)
{
List <PlayerControlledBoardUnit> units = BoardManager.instance.GetEnemiesInRange(currentUnit.CurrentlyOccupiedHexagon,
ability.castRange, ability.AbilityTargetType);
if (units.Count == 0)
{
return(0);
}
PlayerControlledBoardUnit target = units[0];
if (units.Count > 1)
{
target = FindBestTarget(ability, units);
}
a = target;
return(1);
}
/// <summary>
/// Used to display an array
/// </summary>
public void DisplayAbilities()
{
EditorGUI.indentLevel += 1;
for (int i = 0; i < enemyUnit.ListOfAbilities.Count; i++)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(enemyUnit.ListOfAbilities[i].DisplayName, GUILayout.MaxWidth(200));
if (GUILayout.Button("Select"))
{
AbilityDescription ab = enemyUnit.ListOfAbilities[i];
EditorUtility.FocusProjectWindow();
Selection.activeObject = ab;
}
if (GUILayout.Button("Delete"))
{
enemyUnit.ListOfAbilities.RemoveAt(i);
i--;
}
EditorGUILayout.EndHorizontal();
}
EditorGUI.indentLevel -= 1;
}
/// <summary>
/// Activates an ability
/// </summary>
public AbilityDescription ActivateAbility(int abilityNumber)
{
if (ListOfAbilities[abilityNumber].currentCooldown > 0)
{
return(null);
}
AbilityInProgress = ListOfAbilities[abilityNumber];
if (AbilityInProgress.AbilityTargetType != AbilityDescription.TargetType.CustomTemplate)
{
BoardManager.instance.HighlightAbility(GetComponent <BoardUnit>().CurrentlyOccupiedHexagon, AbilityInProgress, true);
TemplateManager.instance.StartHexHighlighting(GetComponent <BoardUnit>(), AbilityInProgress);
}
else
{
TemplateManager.instance.StartHighlighting(GetComponent <BoardUnit>(), AbilityInProgress);
}
return(ListOfAbilities[abilityNumber]);
}
/// <summary>
/// Finds the best target for an ability given a number of targets
/// </summary>
public PlayerControlledBoardUnit FindBestTarget(AbilityDescription ability, List <PlayerControlledBoardUnit> targets)
{
PlayerControlledBoardUnit currTarget = targets[0];
float potentialDamage = 0;
foreach (DebuffEffect debuff in ability.debuffs)
{
if (debuff.DebuffType == DebuffEffect.Debuff.Damage)
{
potentialDamage += debuff.Damage;
}
}
foreach (PlayerControlledBoardUnit target in targets)
{
if (target.CurrentHealth < potentialDamage) //If we have lethal damage, its a no brainer
{
return(target);
}
if (target.CurrentHealth / target.MaxHealth //If we find someone with lower health go for them
< currTarget.CurrentHealth / currTarget.MaxHealth)
{
currTarget = target;
}
if (currTarget.UnitClass == PlayerControlledBoardUnit.PlayerClass.Warrior)
{
if (target.UnitClass == PlayerControlledBoardUnit.PlayerClass.Wizard ||
target.UnitClass == PlayerControlledBoardUnit.PlayerClass.Support)
{
currTarget = target;
}
}
}
return(currTarget);
}
private Monster BuildSpecialAbilityList(Monster rv)
{
var pos = findStartIndex("Special Abilities");
if (!pos.HasValue)
{
return(rv);
}
var position = pos.GetValueOrDefault();
position++;
var dataPoint = data[position].InnerHtml;
while (dataPoint.Trim() != "Description")
{
Console.WriteLine("*****");
Console.WriteLine(dataPoint);
AbilityDescription ad = null;
if (dataPoint.Contains("(Ex)") || dataPoint.Contains("(Su)") || dataPoint.Contains("(Sp)"))
{
// dataPoint description
ad = new AbilityDescription();
ad.Name = dataPoint;
position++;
var next = data[position + 1].InnerHtml;
do
{
dataPoint = data[position].InnerHtml;
ad.Description += dataPoint;
next = data[position + 1].InnerHtml;
position++;
} while (!(next.Contains("(Ex)") || next.Contains("(Su)") || next.Contains("(Sp)") || next == "Description"));
}
rv.Abilities.AbilityDescriptions.Add(ad);
dataPoint = data[position].InnerHtml;
}
return(rv);
}
/// <summary>
/// Receives an ability hit and applies status effects
/// </summary>
public void ReceiveAbilityHit(AbilityDescription ability, List <AbilityModifier> modifiers = null)
{
if (modifiers != null)
{
foreach (AbilityModifier mod in modifiers)
{
if (mod.ModifierType == AbilityModifier.Modifier.RemoveStunEffect)
{
for (int i = 0; i < ability.debuffs.Count; i++)
{
DebuffEffect e = ability.debuffs [i];
if (e.DebuffType == DebuffEffect.Debuff.Stun)
{
ability.debuffs.RemoveAt(i);
i--;
}
}
}
}
}
for (int i = 0; i < ability.debuffs.Count; i++)
{
DebuffEffect effect = ability.debuffs [i];
if (effect.RequireUnstableStatic && !hasUnstableStatic)
{
ability.debuffs.RemoveAt(i);
i--;
}
else if (effect.RequireUnstableStatic && hasUnstableStatic)
{
RemoveUnstableStatic();
}
}
foreach (DebuffEffect effect in ability.debuffs)
{
if (effect.DebuffType == DebuffEffect.Debuff.Damage)
{
ApplyDamage((int)effect.Damage, modifiers);
}
else if (effect.DebuffType == DebuffEffect.Debuff.Slow)
{
ApplySlow(effect.SlowPercent);
}
else if (effect.DebuffType == DebuffEffect.Debuff.Stun)
{
ApplyStun();
}
else if (effect.DebuffType == DebuffEffect.Debuff.Silence)
{
ApplySilence();
}
else if (effect.DebuffType == DebuffEffect.Debuff.Root)
{
ApplyRoot();
}
else if (effect.DebuffType == DebuffEffect.Debuff.UnstableStatic)
{
ApplyUnstableStatic();
}
else if (effect.DebuffType == DebuffEffect.Debuff.Enfeeble)
{
ApplyEnfeeble();
}
else if (effect.DebuffType == DebuffEffect.Debuff.StaticGrip)
{
HandleStaticGrip(effect);
}
if (effect.EffectDurationType == StatusEffect.EffectDuration.OverTime)
{
if (debuffs.Contains(effect))
{
debuffs.Remove(effect);
}
debuffs.Add(new DebuffEffect(effect));
}
}
foreach (BuffEffect effect in ability.buffs)
{
if (effect.BuffType == BuffEffect.Buff.RemoveDebuffs)
{
debuffs.Clear();
RemoveStuns();
RemoveSlows();
RemoveRoots();
RemoveSilences();
RemoveUnstableStatic();
}
else if (effect.BuffType == BuffEffect.Buff.Absorb)
{
ApplyAbsorb((int)effect.amount);
}
else if (effect.BuffType == BuffEffect.Buff.FullHeal)
{
ApplyHeal(int.MaxValue);
}
else if (effect.BuffType == BuffEffect.Buff.Heal)
{
ApplyHeal((int)effect.amount);
}
else if (effect.BuffType == (BuffEffect.Buff.MovementIncrease))
{
ApplyMovementIncrease(Mathf.RoundToInt(effect.amount));
}
else if (effect.BuffType == BuffEffect.Buff.StaticShell)
{
HandleStaticShell(effect);
}
if (effect.EffectDurationType == StatusEffect.EffectDuration.OverTime)
{
if (buffs.Contains(effect))
{
buffs.Remove(effect);
}
buffs.Add(new BuffEffect(effect));
}
}
}
public override void OnInspectorGUI()
{
serializedObject.Update();
abilityEditor = (AbilityDescription)target;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Ability Name");
abilityEditor.DisplayName = abilityEditor.name;
abilityEditor.DisplayName = EditorGUILayout.TextField(abilityEditor.DisplayName);
if (abilityEditor.name != abilityEditor.DisplayName)
{
AssetDatabase.RenameAsset(AssetDatabase.GetAssetPath(abilityEditor).ToString(), abilityEditor.DisplayName);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.LabelField("Tooltip");
abilityEditor.TooltipText = EditorGUILayout.TextArea(abilityEditor.TooltipText);
// if (abilityEditor.AbilityIcon != null)
// GUILayout.Label (abilityEditor.AbilityIcon);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Drag New Sprite Here", GUILayout.MaxWidth(200));
EditorGUILayout.PropertyField(serializedObject.FindProperty("newTexture"), GUIContent.none);
if (Event.current.type == EventType.Repaint && abilityEditor.newTexture != null) //repaint only to avoid layout errors
{
abilityEditor.UpdateIcon();
}
EditorGUILayout.EndHorizontal();
// EditorGUILayout.BeginHorizontal();
// abilityEditor.AbilityDamageType = (AbilityDescription.DamageType)EditorGUILayout.EnumPopup("Ability Target Type", abilityEditor.AbilityDamageType);
// EditorGUILayout.EndHorizontal ();
EditorGUILayout.BeginHorizontal();
abilityEditor.AbilityTargetType = (AbilityDescription.TargetType)EditorGUILayout.EnumPopup("Ability Target Type", abilityEditor.AbilityTargetType);
EditorGUILayout.EndHorizontal();
if (abilityEditor.AbilityTargetType == AbilityDescription.TargetType.TargetHexagon)
{
abilityEditor.HexDuration = EditorGUILayout.IntField("Hexagon Duration", abilityEditor.HexDuration);
}
if (abilityEditor.AbilityTargetType == AbilityDescription.TargetType.CustomTemplate)
{
EditorGUILayout.BeginHorizontal();
abilityEditor.TemplateType = (TemplateManager.Target)EditorGUILayout.EnumPopup("Template Type", abilityEditor.TemplateType);
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.BeginHorizontal();
abilityEditor.Template = (TemplateManager.TargetTemplate)EditorGUILayout.EnumPopup("Template", abilityEditor.Template);
abilityEditor.TemplateSize = EditorGUILayout.IntField("TemplateSize", abilityEditor.TemplateSize);
EditorGUILayout.EndHorizontal();
// EditorGUILayout.BeginHorizontal();
// EditorGUILayout.LabelField ("TemplateLength", GUILayout.MaxWidth (100));
// abilityEditor.TemplateLength = EditorGUILayout.IntField (abilityEditor.TemplateLength);
// EditorGUILayout.LabelField ("TemplateWidth", GUILayout.MaxWidth (100));
// abilityEditor.TemplateWidth = EditorGUILayout.IntField (abilityEditor.TemplateWidth);
// EditorGUILayout.EndHorizontal ();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Friendly Fire Enabled?");
abilityEditor.FriendlyFireEnabled = EditorGUILayout.Toggle(abilityEditor.FriendlyFireEnabled);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
if (abilityEditor.FriendlyFireEnabled)
{
EditorGUILayout.LabelField("Self Fire Enabled?");
abilityEditor.SelfFireEnabled = EditorGUILayout.Toggle(abilityEditor.SelfFireEnabled);
}
else
{
abilityEditor.SelfFireEnabled = false;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
if (abilityEditor.AbilityTargetType == AbilityDescription.TargetType.CustomTemplate)
{
EditorGUILayout.LabelField("Require Valid Hexagon Target");
abilityEditor.RequireSourceHexagon = EditorGUILayout.Toggle(abilityEditor.RequireSourceHexagon);
}
EditorGUILayout.EndHorizontal();
// EditorGUILayout.BeginHorizontal();
// EditorGUILayout.LabelField ((abilityEditor.AbilityDamageType == AbilityDescription.DamageType.Heal
// || abilityEditor.AbilityDamageType == AbilityDescription.DamageType.Absorb) ? "Healing" : "Damage");
// abilityEditor.damage = EditorGUILayout.IntField (abilityEditor.damage);
// EditorGUILayout.EndHorizontal ();
EditorGUILayout.BeginHorizontal();
// if (abilityEditor.AbilityAbilityType == AbilityDescription.AbilityType.AreaOverTime) {
// EditorGUILayout.LabelField ("Duration");
// abilityEditor.Duration = EditorGUILayout.IntField (abilityEditor.Duration);
// }
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Cast Range", GUILayout.MaxWidth(100));
abilityEditor.castRange = EditorGUILayout.IntField(abilityEditor.castRange);
EditorGUILayout.LabelField("Cooldown", GUILayout.MaxWidth(100));
abilityEditor.Cooldown = EditorGUILayout.IntField(abilityEditor.Cooldown);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
// if (abilityEditor.AbilityAbilityType == AbilityDescription.AbilityType.Area || abilityEditor.AbilityAbilityType == AbilityDescription.AbilityType.AreaOverTime) {
// EditorGUILayout.LabelField ("AOE Range");
// abilityEditor.AreaOfEffectDistance = EditorGUILayout.IntField (abilityEditor.AreaOfEffectDistance);
// }
EditorGUILayout.EndHorizontal();
if (GUILayout.Button("Create New Debuff"))
{
abilityEditor.debuffs.Add(new DebuffEffect());
}
if (abilityEditor.debuffs.Count > 0)
{
ShowDebuffList();
}
if (GUILayout.Button("Create New Buff"))
{
abilityEditor.buffs.Add(new BuffEffect());
}
if (abilityEditor.buffs.Count > 0)
{
ShowBuffList();
}
serializedObject.ApplyModifiedProperties();
serializedObject.Update();
EditorUtility.SetDirty(abilityEditor); //Have to set dirty or it wont update
}