public ChainedAbility(IAbility ability, TargetType targetType, bool mustBeReady)
{
Instance = ability;
TargetType = targetType;
MustBeReady = mustBeReady;
ClassType = Instance.GetType();
}
public IAbility AddAbility(IAbility ability)
{
_abilityRepository.Create(ability);
foreach (IAbility childAbility in ability.Abilities)
AddAbility(childAbility);
return GetAbility(ability.Name);
}
public void takeGeneralDamage(Damage damage, IAbility ability, IBattleCharacter source)
{
List<GameObject> children = listChildren(this.gameObject);
foreach (GameObject child in children)
{
child.GetComponent<IBattleCharacter>().takeGeneralDamage(damage,ability,source);
}
}
private void IncrementSkillLevel(IDictionary <int, int> skills, IAbility ability)
{
if (skills.TryGetValue(ability.Skill.Id, out int level))
{
skills[ability.Skill.Id] = level + ability.Level;
}
else
{
skills.Add(ability.Skill.Id, ability.Level);
}
}
public IAbility Add(IAbility ability)
{
if (ability is OilAbility)
{
return(this);
}
else
{
return(ability);
}
}
public SetupTargets(
IAbility parent,
TargetFilter filter,
TargetNotification notification,
int priority = 0)
{
Parent = parent;
Priority = priority;
TargetFilter = filter;
Notification = notification;
}
public IAbility Add(IAbility ability)
{
if (ability is CannonballShotAbility)
{
return(new SeaMineShotAbility());
}
else
{
return(ability);
}
}
public IAbility Add(IAbility ability)
{
if (ability is SpeedSmallBoostAbility)
{
return(new SpeedFlyingBoostAbility());
}
else
{
return(ability);
}
}
public bool Authorize(IRole role, IAbility ability)
{
if (role.Abilities.Contains(ability))
return true;
foreach (IAbility root in role.Abilities)
if (_Authorize(root, ability))
return true;
return false;
}
public IAbility Add(IAbility ability)
{
if (ability is SpeedSmallBoostAbility)
{
return(this);
}
else
{
return(ability);
}
}
public IAbility[] GetAbilities(ICharacter character)
{
var list = character.Abilities.ToList();
var results = new IAbility[10];
for (int i = 0; i < results.Length; i++)
{
results[i] = Bindings[i].HasValue ? list[Bindings[i].Value] : null;
}
return(results);
}
public void AddAbility(int level, int abilityId)
{
IAbility ability = DependencyContainer.Instance.GetInstance <IAbilityManager>()[abilityId];
if (ability == null)
{
Log.Default.WriteLine(LogLevels.Warning, "Trying to add unknown ability [id:{0}] to class [{1}]", abilityId, Name);
return;
}
//
AddAbility(level, ability);
}
public Queue <AbilityExecuteParameters> CreateAbiltyQueue(IGameUnit user, IAbility abilityToExecute, IEnumerable <IGameMapObject> targets, MapPoint targetPoint, IGameMap gameMap)
{
// Create our action queue
var abilityExecuteQueue = new Queue <AbilityExecuteParameters>();
// For now we'll only target game units from the targets list
var gameUnitTargets = targets.OfType <IGameUnit>().ToList();
// Sanity check: If we _don't_ have any game units then
if (!gameUnitTargets.Any())
{
return(abilityExecuteQueue);
}
// Create a counter-attack object for each target
var targetCounterAttacks = gameUnitTargets.Where(x => abilityToExecute.CanBeCountered).Where(x => x.UnitFaction != user.UnitFaction).Select(counteringUnit =>
{
var counterAbility = GetAutoAttackAbility(counteringUnit, user);
return(new
{
CounterUnit = counteringUnit,
CounterAbility = counterAbility,
CounterRepeat = counterAbility != null ? DamageCalculator.RepeatCount(counterAbility, counteringUnit, user) : 0,
});
}).Where(x => x.CounterAbility != null).ToList();
// We need the number of repeats total. This'll govern how many loops we do of filling our queue
var userRepeatCount = gameUnitTargets.Select(target => DamageCalculator.RepeatCount(abilityToExecute, user, target)).Max();
var maxRepeatCount = targetCounterAttacks.Any() ? Math.Max(userRepeatCount, targetCounterAttacks.Max(x => x.CounterRepeat)) : userRepeatCount;
// Pregen list
var counterTargetsList = new List <IGameMapObject> {
user
};
for (var i = 0; i < maxRepeatCount; i++)
{
// Add the user's action to the queue if they have this many repeats
if (i < userRepeatCount)
{
abilityExecuteQueue.Enqueue(new AbilityExecuteParameters(user, abilityToExecute, null, targets, targetPoint, gameMap));
}
// Then add all the counter attacks!
foreach (var counterAttack in targetCounterAttacks.Where(x => i < x.CounterRepeat))
{
abilityExecuteQueue.Enqueue(new AbilityExecuteParameters(counterAttack.CounterUnit, counterAttack.CounterAbility, user, counterTargetsList, user.MapPoint, gameMap));
}
}
return(abilityExecuteQueue);
}
public void UpdateUnlockedAbilities(CharacterAttributes attributes)
{
for (int i = potentialAbilities.Count - 1; i >= 0; i--)
{
IAbility potential = potentialAbilities[i];
if (attributes.Strength >= potential.StrengthRequired && attributes.Stamina >= potential.StaminaRequired && attributes.Intelligence >= potential.IntelligenceRequired)
{
potentialAbilities.Remove(potential);
unlockedAbilities.Add(potential);
}
}
}
private bool IsMatchingExcludedSkill(IAbility ability)
{
foreach (IAbility desiredAbility in DesiredAbilities.Where(x => x.Level == 0))
{
if (DataUtility.AreAbilitiesOnSameSkill(ability, desiredAbility))
{
return(true);
}
}
return(false);
}
public override bool PerformLearnedCheck(IAbility ability)
{
bool returnResult = base.PerformLearnedCheck(ability);
if (!returnResult)
{
CombatLogUI.MyInstance.WriteCombatMessage("You have not learned the ability " + ability.DisplayName + " yet");
//Debug.Log("You have not learned the ability " + ability.MyName + " yet");
//Debug.Log("ability.MyUseableWithoutLearning: " + ability.MyUseableWithoutLearning + "; abilityList.Contains(" + keyName + "): " + abilityList.ContainsKey(keyName));
}
return(returnResult);
}
public void AddAbility(int level, string abilityName)
{
IAbility ability = DependencyContainer.Instance.GetInstance <IAbilityManager>()[abilityName];
if (ability == null)
{
Log.Default.WriteLine(LogLevels.Error, "Trying to add unknown ability [{0}] to race [{1}]", abilityName, Name);
return;
}
//
AddAbility(level, ability);
}
private bool IsMatchingDesiredAbilities(IAbility ability)
{
foreach (IAbility desiredAbility in DesiredAbilities)
{
if (DataUtility.AreAbilitiesOnSameSkill(ability, desiredAbility))
{
return(true);
}
}
return(false);
}
/// <summary>
/// 1能力についての能力付加確率を返す(EXTRA補正無し)
/// </summary>
/// <returns></returns>
public static float GetProbability(IAbility objective, Weapon weapon1, Weapon weapon2, Weapon weapon3 = null)
{
IEnumerable <Weapon> weapons = (new Weapon[] { weapon1, weapon2, weapon3 }).Where(w => w != null);
if (objective is ゴミ)
{
return(1.00f);
}
if (objective is Boost)
{
return(1.00f);
}
if (objective is Soul || objective is Special_up)
{
int num = weapons.Count(weapon => weapon.ContainsAbility(objective));
return(Data.PROB_SOUL[Data.INH[num]]);
}
else if (objective is Ability)
{
ILevel ab_lv = objective as ILevel;
int inh_num = weapons.Count(weapon => weapon.ContainsAbility(objective));
float inh_prob = (inh_num >= 1) ? Data.PROB_NORMAL_ABILITY[ab_lv.Level, Data.INH[inh_num]] : 0.0f;
bool generable = weapons.Any(weapon => weapon.ContainsAbility(パワー.GetLv(ab_lv.Level))) &&
weapons.Any(weapon => weapon.ContainsAbility(シュート.GetLv(ab_lv.Level))) &&
weapons.Any(weapon => weapon.ContainsAbility(テクニック.GetLv(ab_lv.Level)));
float gen_prob = (generable) ? Data.PROB_NORMAL_ABILITY[ab_lv.Level, Data.GEN_SP] : 0.0f;
return(Math.Max(inh_prob, gen_prob));
}
else if (objective is Basic_up || objective is Additional)
{
ILevel ab_lv = objective as ILevel;
bool mutation_amp = (objective is IMutationAmplifiable) && weapons.Any(weapon => weapon.ContainsAbility(ミューテーション.GetLv(1)));
bool soul_amp = !mutation_amp && weapons.Any(weapon => weapon.Any(ab => ab is Soul && (ab as Soul).IsAmplifiableAbility(objective))); // !mutation_ampはミューテーションによる増加がある場合はソールについて調べる必要がない為
float[,] prob_table = PROB_TABLE[(objective is Basic_up) ? 0 : 1, (mutation_amp) ? 2 : (soul_amp) ? 1 : 0];
int inh_num = weapons.Count(weapon => weapon.ContainsAbility(objective));
float inh_prob = (inh_num >= 1) ? prob_table[ab_lv.Level, Data.INH[inh_num]] : 0.0f;
IAbility gen_ab = ab_lv.GetInstanceOfLv(ab_lv.Level - 1);
int gen_num = weapons.Count(weapon => weapon.ContainsAbility(gen_ab));
float gen_prob = (gen_num >= 2) ? prob_table[ab_lv.Level - 1, Data.GEN[gen_num]] : 0.0f;
return(Math.Max(inh_prob, gen_prob));
}
Debug.Assert(false);
return(0.0f);
}
public Ability(IAbility abilityStats)
{
name = abilityStats.Name;
damage = abilityStats.Damage;
range = abilityStats.Range;
accuraccy = abilityStats.Accuracy;
length = abilityStats.Length;
width = abilityStats.Width;
aoe = abilityStats.Shape > 0;
description = abilityStats.Description;
isPhysical = abilityStats.IsPhysical;
aoeShape = abilityStats.Shape;
}
public Hero(int life,
double abilityPossibility,
IAbility ability,
int minPunch,
int maxPunch
)
{
Life = life;
AbilityPossibility = abilityPossibility;
Ability = ability;
MinPunch = minPunch;
MaxPunch = maxPunch;
}
public IAbility Add(IAbility ability)
{
//if (ability is ShieldTierOneAbility) return new ShieldTierFourAbility();
if (ability is ShieldTierOneAbility)
{
return(this);
}
else
{
return(ability);
}
}
public Actor CanUse(IAbility use)
{
use = use ?? throw new ArgumentNullException(nameof(use));
if (this.Abilities.Contains(use))
{
throw new ArgumentException(message: $"Actor {this.Name} already has ability {use.Name}");
}
else
{
this.Abilities.Add(use);
return(this);
}
}
public void PreviousAbility(bool secondary = false)
{
if (secondary)
{
_idxSecondary = (_idxSecondary - 1 + _secondaryAbilities.Count) % _secondaryAbilities.Count;
_activeSecondary = _secondaryAbilities[_idxSecondary];
}
else
{
_idxPrimary = (_idxPrimary - 1 + _primaryAbilities.Count) % _primaryAbilities.Count;
_activePrimary = _primaryAbilities[_idxPrimary];
}
}
public PlayerMoveState(
IFogOfWar fogOfWar,
IPlayerFogOfWar playerFogOfWar,
IMouse mouse,
IAbility ability,
IGameMap gameMap)
{
_fogOfWar = fogOfWar;
_playerFogOfWar = playerFogOfWar;
_mouse = mouse;
_ability = ability;
_gameMap = gameMap;
}
public void NextAbility(bool secondary = false)
{
if (secondary)
{
_idxSecondary = (_idxSecondary + 1) % _secondaryAbilities.Count;
_activeSecondary = _secondaryAbilities[_idxSecondary];
}
else
{
_idxPrimary = (_idxPrimary + 1) % _primaryAbilities.Count;
_activePrimary = _primaryAbilities[_idxPrimary];
}
}
public IAbility Add(IAbility ability)
{
//if (ability is SpeedSmallBoostAbility) return new SuperMegaWTFSpeedAbility();
if (ability is SpeedSmallBoostAbility)
{
return(this);
}
else
{
return(ability);
}
}
public override bool Process(ICharacter source, ICharacter victim, IAbility ability, CombatHelpers.AttackResults attackResult)
{
if (victim.Auras.Any(x => x.Ability != null && x.Ability == DependencyContainer.Instance.GetInstance <IAbilityManager>().WeakenedSoulAbility))
{
source.Act(ActOptions.ToCharacter, "{0} cannot be targeted by {1}.", victim, ability.Name);
return(false);
}
int amount = ComputeAttributeBasedAmount(source, SecondaryAttributeTypes.SpellPower, 45.9m);
DependencyContainer.Instance.GetInstance <IWorld>().AddAura(victim, ability, source, AuraModifiers.DamageAbsorb, amount, AmountOperators.Fixed, ability.Duration, true);
DependencyContainer.Instance.GetInstance <IWorld>().AddAura(victim, DependencyContainer.Instance.GetInstance <IAbilityManager>().WeakenedSoulAbility, source, AuraModifiers.None, 0, AmountOperators.None, 15, true);
return(true);
}
public IAbility Add(IAbility ability)
{
//if (ability is OilAbility) return new SpikesAbility();
if (ability is OilAbility)
{
return(new LandMineAbility());
}
else
{
return(ability);
}
}
public void Animate(IAbility ability, ICharacter character)
{
GameObject proj = (GameObject)Instantiate(Resources.Load("Spark"));
proj.transform.position = this.transform.position;
proj.SendMessage("SetCharacter", character);
proj.SendMessage("SetAttack", ability);
this.ability = ability;
this.character = character;
this.isBurst = true;
this.count = 0;
}
public void StartPerform(IAbility ability)
{
if (ability.CanIExecute() == false)
{
return;
}
ActionModifierCheck(ability, ABILITYMODIFIEREXECUTIONTIME.EARLY);
if (ability.CanIExecute() == false)
{
return;
}
ability.OnStartExecute();
}
public bool TryExecute(GameModel state)
{
if (Character == null)
{
Character = state.CharacterCollection.Single(c => c.Id == CharacterId);
}
if (Ability == null)
{
Ability = Character.CharacterClass.Abilities.Single(a => a.Name == AbilityName);
}
return(Character.Cast(state.CharacterFinder, Ability, Target));
}
protected override void BeginAbilityCommon(IAbility ability, GameObject target)
{
base.BeginAbilityCommon(ability, target);
if (currentCastAbility != null && currentCastAbility.RequiresGroundTarget == true)
{
Vector3 groundTarget = Vector3.zero;
if (baseCharacter != null && baseCharacter.CharacterController != null && baseCharacter.CharacterController.MyTarget != null)
{
groundTarget = baseCharacter.CharacterController.MyTarget.transform.position;
}
SetGroundTarget(groundTarget);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AbilityReport"/> class.
/// </summary>
/// <param name="actor">The actor.</param>
/// <param name="ability">The ability.</param>
public AbilityReport(INamed actor, IAbility ability)
{
if (ability == null)
{
throw new ArgumentNullException(nameof(ability));
}
if (actor == null)
{
throw new ArgumentNullException(nameof(actor));
}
Ability = ability;
Actor = actor;
}
protected List<IWeapon> weapons; //the weapons installed on the ship
#endregion Fields
#region Constructors
/// <summary>
/// Instance a spaceship.
/// When inheriting from this class, it is important to set the animationFrame.
/// To animate, make the method "public override void Update(GameTime gameTime){//Your animation code here}"
/// </summary>
/// <param name="mass">The mass of the ship in kilograms</param>
/// <param name="health">The maximum health of the ship, current starts at maximum</param>
/// <param name="armor">The armor of the ship, starts at 100% effectiveness</param>
/// <param name="blastRadius">The blast radius of the shp, the higher number, the bigger explosion at death</param>
/// <param name="blastDamage">The damage of the explosion</param>
/// <param name="registration">The connection of ownership between a ship and a player</param>
/// <param name="position">The starting position of the ship</param>
/// <param name="rotation">The starting rotation of the ship, in radians</param>
/// <param name="graphic">The sprite or spritesheet that represents the ship</param>
public SpaceShip(double mass, double health, double armor, double blastRadius, double blastDamage, Ownership registration, Vector2 position, double rotation, Texture2D graphic)
: base(position, rotation, Vector2.Zero, Vector2.Zero, mass, 0, health, health, armor, 100, blastRadius, blastDamage, graphic)
{
currentThrust = 0;
this.registration = registration;
weapons = new List<IWeapon>();
weapons.Add(ConcreteWeaponFactory.CreateWeapon("gun"));
currentWeapon = weapons[0];
abilities = new List<IAbility>();
abilities.Add(ConcreteAbilityFactory.CreateAbility("shield"));
currentAbility = abilities[0];
shopString = new Dictionary<String, String>();
shopWindow = "main";
CreateShop();
}
public BlockedAbility(IAbility ability, DateTime dateTime)
{
this.Ability = ability;
this.BlockedDateAndTime = dateTime;
}
public BlockedAbility(IAbility ability, DateTime dateTime)
{
Ability = ability;
BlockedDateAndTime = dateTime;
}
public virtual void PreviousAbility()
{
int index = abilities.IndexOf(currentAbility);
//decrement ability or go to end of abilities array
if (index > 0)
{
currentAbility = abilities[index - 1];
}
else
{
currentAbility = abilities[abilities.Count - 1];
}
}
public virtual void NextAbility()
{
int index = abilities.IndexOf(currentAbility);
//increment ability or go to start of abilities array
if (index + 1 < abilities.Count)
{
currentAbility = abilities[index + 1];
}
else
{
currentAbility = abilities[0];
}
}
private void AddChildAbilities(IAbility root, HashSet<IAbility> abilities)
{
foreach (IAbility childAbility in root.Abilities)
{
abilities.Add(childAbility);
AddChildAbilities(childAbility, abilities);
}
}
public void SetAbility(IAbility newAbility)
{
ability = newAbility;
ability.SetPlayer(this);
PowerMeterHUD.instance.gameObject.SetActive (true);
}
/// <summary>
/// (Non-Blocking) Casts the provided spell on the provided target requiring all conditions to be satisfied prior to
/// casting.
/// </summary>
/// <returns>Returns true if the cast is successful</returns>
public static async Task<bool> CastOnTarget(WoWUnit target, IAbility ability, List<ICondition> conditions)
{
foreach (var condition in conditions)
if (!condition.Satisfied())
{
if (Main.Debug && !(condition is IsOffGlobalCooldownCondition))
{
if (Main.Debug)
{
Log.Diagnostics("In " + ability + " call.");
}
if (Main.Debug)
{
Log.Diagnostics("Failed at condition: " + condition);
}
if (Main.Debug && ability is Rupture)
{
Log.Diagnostics("Has Target Rupture up? :" + target.AuraExists(ability.Spell.Id));
}
// if(Main.Debug) Log.Diagnostics("current Target: " + target);
}
return false;
}
//Check if we should cast Ability depending on Diminishing Return
/*
switch (ability.DrCategory)
{
case DrCategory.None:
if (Main.Debug) Log.Diagnostics("In Switchcase none");
break;
case DrCategory.Disoriented:
{
if (Main.Debug) Log.Diagnostics("In Switchcase Desoriented, target : "+target.SafeName);
if (DiminishingReturnManager.Instance.GetDrLevel(target, DrCategory.Disoriented) >= 3)
{
Log.Combat(String.Format("Blocked {0} from Casting because Target is on Immune-DR",
ability.Spell.Name));
return false;
}
break;
}
}
//Check for sapped targets
if (ability is SapAbility)
{
if (!UnitManager.Instance.LastSappedUnits.ContainsKey(target))
{
if (!SpellManager.HasSpell(ability.Spell)) return false;
if (!SpellManager.CanCast(ability.Spell)) return false;
if (!SpellManager.Cast(ability.Spell, target)) return false;
Log.AppendLine(string.Format("[{0}] Casted {1} on {2}(Energy: {3}, ComboPoints: {4} HP: {5:0.##}%)",
ability.Category,
ability.Spell.Name,
target == null ? "Nothing" : (target.IsMe ? "Me" : target.SafeName),
StyxWoW.Me.CurrentEnergy,
StyxWoW.Me.ComboPoints,
StyxWoW.Me.HealthPercent
), Colors.CornflowerBlue);
UnitManager.Instance.LastSappedUnits.Add(target, DateTime.Now + TimeSpan.FromSeconds(5));
await CommonCoroutines.SleepForLagDuration();
return true;
}
//We sapped that target in the last 5 seconds, do not sap again, get another target
return false;
}
*/
if (!SpellManager.HasSpell(ability.Spell)) return false;
if (!SpellManager.CanCast(ability.Spell)) return false;
if (!SpellManager.Cast(ability.Spell, target)) return false;
var logColor = Colors.CornflowerBlue;
switch (ability.Category)
{
case AbilityCategory.Heal:
logColor = Colors.Yellow;
break;
case AbilityCategory.Defensive:
logColor = Colors.LightGreen;
break;
case AbilityCategory.Buff:
logColor = Colors.Plum;
break;
}
{
Log.AppendLine(string.Format("[{0}] Casted {1} on {2}(Energy: {3}, ComboPoints: {4} HP: {5:0.##}%)",
ability.Category,
ability.Spell.Name,
target == null ? "Nothing" : (target.IsMe ? "Me" : target.SafeName),
StyxWoW.Me.CurrentEnergy,
StyxWoW.Me.ComboPoints,
StyxWoW.Me.HealthPercent
), logColor);
}
await CommonCoroutines.SleepForLagDuration();
return true;
}
//-------------------------------------------------------------------------------
//
public void SetAbilities(IAbility[] abilities)
{
int index = 0;
foreach (var cmbAbility in ABILITY_COMBOBOXES) {
cmbAbility.SelectedItem = abilities[index];
++index;
}
}
private bool _Authorize(IAbility root, IAbility query)
{
if (root.Abilities.Contains(query))
return true;
foreach (IAbility childAbility in root.Abilities)
{
if (_Authorize(childAbility, query))
return true;
}
return false;
}
public void AssignAbility(IAbility ability)
{
throw new NotImplementedException();
}
/// <summary>
/// (Non-Blocking) Casts the provided spell on the provided target requiring all conditions to be satisfied prior to
/// casting.
/// </summary>
/// <returns>Returns true if the cast is successful</returns>
public static async Task<bool> CastOnTarget(WoWUnit target, IAbility ability, List<ICondition> conditions)
{
foreach (var condition in conditions)
if (!condition.Satisfied()) return false;
if (!SpellManager.HasSpell(ability.Spell)) return false;
if (!SpellManager.CanCast(ability.Spell)) return false;
if (!SpellManager.Cast(ability.Spell, target)) return false;
var logColor = Colors.CornflowerBlue;
switch (ability.Category)
{
case AbilityCategory.Heal:
logColor = Colors.Yellow;
break;
case AbilityCategory.Defensive:
logColor = Colors.LightGreen;
break;
case AbilityCategory.Bloodtalons:
logColor = Colors.YellowGreen;
break;
case AbilityCategory.Pandemic:
logColor = Colors.Blue;
break;
case AbilityCategory.Buff:
logColor = Colors.Plum;
break;
}
if (StyxWoW.Me.Specialization == WoWSpec.DruidGuardian)
{
Log.AppendLine(
string.Format("[{0}] Casted {1} on {2} {3}(HP: {4:0.##}%, Rage: {5:0.##}%, SE = {6}) {7}",
ability.Category,
ability.Spell.Name,
target == null ? "Nothing" : (target.IsMe ? "Me" : target.SafeName),
target == null
? "No Guid"
: (target.IsMe ? string.Empty : "[" + UnitManager.GuidToUnitId(target.Guid) + "] "),
StyxWoW.Me.HealthPercent,
StyxWoW.Me.RagePercent,
UnitManager.Instance.LastKnownSurroundingEnemies.Count,
target == null
? string.Empty
: (target.IsMe
? string.Empty
: string.Format("(Target HP = {0:0.##}%, D = {1:0.##} yd, L = {2})",
target.HealthPercent, target.Distance,
target.HasAura(SpellBook.Lacerate)
? target.GetAuraById(SpellBook.Lacerate).StackCount.ToString()
: "0"))
), logColor);
}
else
{
Log.AppendLine(
string.Format("[{0}] Casted {1} on {2} {3}({4}CP: {5}, HP: {6:0.##}%, E: {7:0.##}%, SE = {8}) {9}",
ability.Category,
ability.Spell.Name,
target == null ? "Nothing" : (target.IsMe ? "Me" : target.SafeName),
target == null
? "No Guid"
: (target.IsMe ? string.Empty : "[" + UnitManager.GuidToUnitId(target.Guid) + "] "),
ability.Spell.Id == SpellBook.Rake || ability.Spell.Id == SpellBook.Rip
? string.Format("M: {0:0.##}x, ", SnapshotManager.CurrentMultiplier)
: string.Empty,
StyxWoW.Me.ComboPoints,
StyxWoW.Me.HealthPercent,
StyxWoW.Me.EnergyPercent,
UnitManager.Instance.LastKnownSurroundingEnemies.Count,
target == null
? string.Empty
: (target.IsMe
? string.Empty
: string.Format("(Target HP = {0:0.##}%, D = {1:0.##} ({2:0.##}) yd)",
target.HealthPercent, Math.Abs(target.Distance - target.CombatReach),
target.Distance))
), logColor);
}
await CommonCoroutines.SleepForLagDuration();
return true;
}
public AbilityPickUp(IAbility ability)
{
this.ability = ability;
}
public IAbility UpdateAbility(IAbility ability)
{
RemoveAbility(ability.Id);
AddAbility(ability);
return GetAbility(ability.Name);
}
/// <summary>
/// Assign a set of abilities to a role.
/// </summary>
/// <param name="role">The role that is to be inspected and if nescessary configured</param>
/// <param name="ability">The ability to assign the role if nescessary</param>
public static void RegisterAbility(IRole role,
IAbility ability)
{
RegisterAbilities(role, new List<IAbility> {ability});
}
protected override IEnumerator moveToTarget(Vector3 target, BattleState.State nextState, IAbility ability, float optionalDelay = 0, float stopDist = 1.5F)
{
coroutines.moveToTarget = true;
agent.ResetPath();
if (optionalDelay > 0)
yield return new WaitForSeconds(optionalDelay);
while (anim.GetCurrentAnimatorStateInfo(0).fullPathHash != animHash.getHash("idleState"))
yield return null;
while (!ability.moveToTarget(this.gameObject, target, stopDist))
{
float moveSpeed = agent.velocity.magnitude;
anim.SetFloat(animHash.getHash("moveSpeedFloat"), moveSpeed);
yield return null;
}
agent.Stop();
agent.ResetPath();
anim.SetFloat(animHash.getHash("moveSpeedFloat"), 0.1f);
state.setState(nextState);
coroutines.moveToTarget = false;
}
//-------------------------------------------------------------------------------
//
public void SetAbilities(IAbility[] abilities)
{
foreach (var chb in _checkboxes) {
var ab = chb.Tag as IAbility;
chb.Checked = abilities.Contains(ab);
}
}
public void SuccessfulCast(IAbility ability)
{
}
public override void takeGeneralDamage(Damage damage, IAbility ability, IBattleCharacter source)
{
base.takeGeneralDamage(damage, ability, source);
}
//-------------------------------------------------------------------------------
public static IEnumerable<IEnumerable<IAbility>> GetMaterialAbilities(IAbility ability)
{
if (ability is Basic_up || ability is Additional) {
// (元の能力*1,2,3) or (一つ下の能力*2,3)
yield return new[] { ability, ability, ability };
yield return new[] { ability, ability };
yield return new[] { ability };
ILevel ability_l = ability as ILevel;
int level = ability_l.Level;
if (level > 1) {
//IAbility ab = Activator.CreateInstance(ability.GetType(), level - 1) as IAbility; 下に代替
IAbility ab = ability_l.GetInstanceOfLv(level - 1);
yield return new[] { ab, ab, ab };
yield return new[] { ab, ab };
}
}
else if (ability is Ability) {
// (パワー,シュート,テクニック各1) or (元の能力*1,2,3)
int level = ((ILevel)ability).Level;
yield return new IAbility[] { パワー.GetLv(level), シュート.GetLv(level), テクニック.GetLv(level) };
yield return new[] { ability, ability, ability };
yield return new[] { ability, ability };
yield return new[] { ability };
}
else if (ability is Soul || ability is Special_up) {
// (元の能力*2,3)
yield return new[] { ability, ability, ability };
yield return new[] { ability, ability };
}
yield break;
}
public void FailedCast(IAbility ability)
{
}
private void SetToLevel(int level){
//TODO: handle animation of levelup/down
switch(level){
case 0:
{
speed = 7000;
jumpSpeed = 80000;
maxSpeed = 12f;
maxAirSpeed = 10f;
maxJumpSpeed = 28;
health = 5;
maxHealth = 5;
regenHealth = .1f;
fireAbility.cooldown = 0.2f;
fireAbility.damage = 1;
fireAbility.projectileSpeed = 2000;
rightTriggerAbility = fireAbility;
shieldAbility.cooldown = 1;
shieldAbility.activeTime = 1;
leftTriggerAbility = shieldAbility;
animController.runtimeAnimatorController = animationControllers[0];
rayPoint1.transform.position = new Vector2(transform.position.x + 0.34f, transform.position.y + -0.938f);
rayPoint2.transform.position = new Vector2(transform.position.x + -0.365f, transform.position.y + -0.938f);
sideRayPoint1.transform.position = new Vector2(transform.position.x + .65f, transform.position.y + -0.84f);
sideRayPoint2.transform.position = new Vector2(transform.position.x + .65f, transform.position.y + 0);
sideRayPoint3.transform.position = new Vector2(transform.position.x + .65f, transform.position.y + 0.68f);
ScreenWrapObject wrapObj = GetComponent<ScreenWrapObject>();
wrapObj.SetColliderSize(new Vector2(1.00962f, 1.58734f));
wrapObj.SetColliderOffset(new Vector2(-0.07074118f, -0.05305576f));
wrapObj.InitializeCollliders();
}
break;
case 1:
{
speed = 7000;
jumpSpeed = 80000;
maxSpeed = 12f;
maxAirSpeed = 10f;
maxJumpSpeed = 28;
health = 10;
maxHealth = 10;
regenHealth = 0f;
tentacleAbility.cooldown = 1;
tentacleAbility.damage = 2;
tentacleAbility.width = 1;
tentacleAbility.height = 1;
tentacleAbility.attackSpeed = 1.5f;
// rightTriggerAbility = tentacleAbility;
shieldAbility.cooldown = .5f;
shieldAbility.activeTime = .5f;
leftTriggerAbility = shieldAbility;
animController.runtimeAnimatorController = animationControllers[1];
//resetting raypoint positions
rayPoint1.transform.position = new Vector2(transform.position.x -0.223f, transform.position.y + -1.162f);
rayPoint2.transform.position = new Vector2(transform.position.x + 0.477f, transform.position.y + -1.126f);
sideRayPoint2.transform.position = new Vector2(transform.position.x + 0.993f, transform.position.y + 0);
sideRayPoint3.transform.position = new Vector2(transform.position.x + 0.993f, transform.position.y + 0.741f);
sideRayPoint1.transform.position = new Vector2(transform.position.x + 0.993f, transform.position.y -0.741f);
ScreenWrapObject wrapObj = GetComponent<ScreenWrapObject>();
wrapObj.SetColliderOffset(new Vector2(0f,0f));
wrapObj.SetColliderSize(new Vector2(1.5f, 2f));
wrapObj.InitializeCollliders();
}
break;
case 2:
{
speed = 7000;
jumpSpeed = 80000;
maxSpeed = 12f;
maxAirSpeed = 10f;
maxJumpSpeed = 28;
health = 5;
maxHealth = 5;
regenHealth = .1f;
}
break;
case 3:
{
speed = 7000;
jumpSpeed = 80000;
maxSpeed = 12f;
maxAirSpeed = 10f;
maxJumpSpeed = 28;
health = 10;
maxHealth = 10;
regenHealth = .1f;
}
break;
default:
Debug.LogError("Level Index out of bounds");
break;
}
this.level = level;
}
public static async Task<bool> DropCast(IAbility ability, WoWUnit target, List<ICondition> conditions )
{
foreach (var condition in conditions)
if (!condition.Satisfied())
{
if (Main.Debug) Log.Diagnostics("Failed at condition:" + condition);
return false;
}
if (!SpellManager.HasSpell(ability.Spell)) return false;
if (!SpellManager.CanCast(ability.Spell)) return false;
if (!SpellManager.Cast(ability.Spell, target)) return false;
if (!await Coroutine.Wait(1000, () => StyxWoW.Me.CurrentPendingCursorSpell != null))
{
Log.Diagnostics("Cursor didn't turn into the spell!");
return false;
}
SpellManager.ClickRemoteLocation(target.Location);
var logColor = Colors.CornflowerBlue;
switch (ability.Category)
{
case AbilityCategory.Heal:
logColor = Colors.Yellow;
break;
case AbilityCategory.Defensive:
logColor = Colors.LightGreen;
break;
case AbilityCategory.Buff:
logColor = Colors.Plum;
break;
}
{
Log.AppendLine(string.Format("[{0}] Casted {1} on {2}(Energy: {3}, ComboPoints: {4} HP: {5:0.##}%)",
ability.Category,
ability.Spell.Name,
target == null ? "Nothing" : (target.IsMe ? "Me" : target.SafeName),
StyxWoW.Me.CurrentEnergy,
StyxWoW.Me.ComboPoints,
StyxWoW.Me.HealthPercent
), logColor);
}
await CommonCoroutines.SleepForLagDuration();
return true;
}
public void Equip(IAbility ability)
{
throw new NotImplementedException();
}
public void RemoveAbility(IAbility ability)
{
foreach (IRole role in _roleRepository.Get<IRole>())
role.Abilities.Remove((IAbility)ability);
_abilityRepository.Delete(ability);
}
public bool Authorize(IUser user, IAbility ability)
{
if (user == null || ability == null) return false;
return user.Roles.Any(role => Authorize(role, ability));
}
