public void Use(AbilityUseParams useParams)
{
print("Power attack used by: " + gameObject.name);
float damageToDeal = useParams.baseDamage + config.GetExtraDamage();
useParams.target.TakeDamage(damageToDeal);
}
public void Use(AbilityUseParams useParams)
{
player.Heal(config.GetExtraHealth());
audioSource.clip = config.GetAudioClip(); // TODO find way of moving audio to parent class
audioSource.Play();
PlayParticleEffect();
}
public override void Use(AbilityUseParams useParams)
{
useParams.target = gameObject;
HealSelf();
PlayParticleEffect(useParams);
PlayAbilitySound();
}
public void Use(AbilityUseParams useParams)
{
print("Heal Ability Used by: " + gameObject.name);
ActivateHeal(useParams);
ActivateSound();
PlayParticleSystem();
}
public void Use(AbilityUseParams useParams)
{
print("AoE attack used by: " + gameObject.name);
// TODO: change origin to useParams.target for a TARGETED AoE (currently AoE encircles player)
Vector3 origin = gameObject.transform.position;
float radius = config.GetRadius();
float damageAmount = useParams.baseDamage + config.GetAbilityDamage();
// change origin to target ENEMY // Change movement for BLAST attack
RaycastHit[] targets = Physics.SphereCastAll(origin, radius, origin, radius);
// print("Number of targets" + targets.Length);
// for (var thing = 0; thing < targets.Length; thing++)
// {
// print("Raycasts Hit: " + targets[thing].collider.gameObject.name);
// }
foreach (RaycastHit hit in targets)
{
var target = hit.collider.gameObject.GetComponent <IDamageable>();
if (target != null)
{
target.TakeDamage(damageAmount);
// print("Enemy Hit: " + target);
}
}
}
public void Use(AbilityUseParams useParams)
{
print("Power attack used by: " + gameObject.name);
DealDamage(useParams);
PlayParticleEffect(); // TODO find way of moving audio to parent class
audioSource.clip = config.GetAudioClip();
audioSource.Play();
}
public void DealDamage(AbilityUseParams useParams)
{
abilityUseParams = useParams;
characterManager = abilityUseParams.ability.Behaviour.Character.GetComponent <Character>();
var enemyHealthController = useParams.target.GetComponent <HealthController>();
float primaryStatDamage = CalculatePrimaryStatMultiplier();
float finalDamage = primaryStatDamage - GetArmourValue(abilityUseParams.target);
enemyHealthController.TakeDamage(finalDamage);
UIManager.Instance.TriggerCombatText(enemyHealthController.gameObject.transform.position, finalDamage, CombatTextType.NormalDamage);
}
protected void PlayAbilityAnimation(AbilityUseParams args)
{
var animation = config.GetAbilityAnimation();
animation = RemoveAnimationEvents(animation);
var overrideController = args.self.GetComponent <Character>().OverrideAnimator;
var animator = args.self.GetComponent <Animator>();
overrideController[SPECIAIL_ABILITY_ANIM] = animation;
animator.SetTrigger(SPECIAL_ABILITY_TRIGGER);
}
private void ActivateHeal(AbilityUseParams useParams)
{
if (player)
{
player.Heal(config.GetHealth());
}
else if (enemy)
{
// TODO: add HEAL to enemy script
enemy.TakeDamage(-config.GetHealth());
}
}
protected void PlayParticleEffect(AbilityUseParams useParams)
{
GameObject particleObject = Instantiate(
config.ParticlePrefab,
useParams.target.transform.position,
config.ParticlePrefab.transform.rotation
);
ParticleSystem particleSystem = particleObject.GetComponent <ParticleSystem>();
particleSystem.Play();
Destroy(particleObject, particleSystem.main.duration);
}
AbilityUseParams GetUseParams(GameObject target)
{
var damage = (ability as DaggerSlashConfig).Damage.Value;
var animationName = (ability as DaggerSlashConfig).AnimationName;
var reliantStat = (ability as DaggerSlashConfig).ReliantStat;
var statMultiplier = (ability as DaggerSlashConfig).StatMultiplier;
var hitAnimationName = (ability as DaggerSlashConfig).HitAnimationName;
AbilityUseParams useParams = new AbilityUseParams(target, damage, null, ability, reliantStat, statMultiplier, hitAnimationName);
return(useParams);
}
private void AttemptSpecialAbility(int abilityIndex, Enemy enemy)
{
var energyComponent = GetComponent <Energy>();
var energyCost = abilities[abilityIndex].GetEnergyCost();
if (energyComponent.IsEnergyAvailable(energyCost))
{
energyComponent.ConsumeEnergy(10f);
var abilityParams = new AbilityUseParams(enemy, baseDamage);
abilities[abilityIndex].Use(abilityParams);
}
}
IEnumerator PerformBasicShot(AbilityUseParams useParams)
{
Character.characterAnimationController.StartAbilityAnimation(ability.AnimationName);
yield return(new WaitForSeconds(ability.AbilitySpeed.Value));
Projectile attack = Instantiate(useParams.projectilePrefab, Character.ExitPoints[Character.ExitIndex].position, Quaternion.identity).GetComponent <Projectile>();
attack.Initialize(useParams.target.transform, useParams);
attack.InvokeOnHitTarget += Character.damageController.DealDamage;
StopAttack(ability.AnimationName);
StartCoroutine(UnregisterProjectileEvent(attack, Character.damageController));
}
AbilityUseParams GetUseParams(GameObject target)
{
float damage = (ability as FireballConfig).Damage.Value;
GameObject projectilePrefab = (ability as FireballConfig).ProjectilePrefab;
string animationName = (ability as FireballConfig).AnimationName;
CharacterStat reliantStat = (ability as FireballConfig).ReliantStat;
float statMultiplier = (ability as FireballConfig).StatMultiplier;
var hitAnimationName = (ability as FireballConfig).HitAnimationName;
AbilityUseParams useParams = new AbilityUseParams(target, damage, projectilePrefab, ability, reliantStat, statMultiplier, hitAnimationName);
return(useParams);
}
AbilityUseParams GetUseParams(GameObject target)
{
var damage = (ability as PoisonShotConfig).Damage.Value;
var projectilePrefab = (ability as PoisonShotConfig).ProjectilePrefab;
var animationName = (ability as PoisonShotConfig).AnimationName;
var reliantStat = (ability as PoisonShotConfig).ReliantStat;
var statMultiplier = (ability as PoisonShotConfig).StatMultiplier;
var hitAnimationName = (ability as PoisonShotConfig).HitAnimationName;
AbilityUseParams useParams = new AbilityUseParams(target, damage, projectilePrefab, ability, reliantStat, statMultiplier, hitAnimationName);
return(useParams);
}
protected IEnumerator PerformDaggerSlash(AbilityUseParams useParams)
{
var enemyHealthController = useParams.target.GetComponent <HealthController>();
var enemyHitboxAnimator = useParams.target.GetComponentInChildren <HitAnimationController>().GetComponent <Animator>();
Character.characterAnimationController.StartAbilityAnimation(ability.AnimationName);
yield return(animationDelayRoutine = StartCoroutine(AnimationDelay(ANIMATION_DELAY, enemyHitboxAnimator, (ability as DaggerSlashConfig).HitAnimationName)));
Character.damageController.DealDamage(useParams);
yield return(new WaitForSeconds(ability.AbilitySpeed.Value));
StopAttack(ability.AnimationName);
}
public void TryPerformPowerAttack(Health target)
{
if (!(currentEnergy >= abilities[0].EnergyCost))
{
if (audioSource != null)
{
outOfEnergySound.PlayClip(audioSource);
}
return;
}
ConsumeEnergy(abilities[0].EnergyCost);
var abilityParams = new AbilityUseParams(gameObject, target, player.WeaponSystem.BaseDamage);
abilities[0].Use(abilityParams);
}
protected void PlayEffect(AbilityUseParams args, bool stickToCaster)
{
CompoundParticleSystem vfxSystem = null;
if (stickToCaster)
{
vfxSystem = Instantiate(config.GetCompoundParticleSystem(), args.self.transform).GetComponent <CompoundParticleSystem>();
}
else
{
vfxSystem = Instantiate(config.GetCompoundParticleSystem()).GetComponent <CompoundParticleSystem>();
vfxSystem.CopyRotationAndPositon(args.self.transform);
}
vfxSystem.InitAndPlay(selfDestruct: true);
}
private void AttempSpecialAbility(int abilityIndex)
{
var energyComponent = GetComponent <Energy>();
AbilityConfig specialAbility = abilities[abilityIndex];
if (energyComponent.IsEnergyAvailable(specialAbility.GetEnergyCost()))
{
energyComponent.ConsumeEnergy(specialAbility.GetEnergyCost());
var abilityParams = new AbilityUseParams(this.currentEnemy, baseDamage);
specialAbility.Use(abilityParams);
}
else
{
print("Not enough mana");
}
}
public void TryPerformSpecialAbility(int index)
{
var ability = abilities[index];
if (!(currentEnergy >= ability.EnergyCost))
{
if (audioSource != null)
{
outOfEnergySound.PlayClip(audioSource);
}
return;
}
ConsumeEnergy(ability.EnergyCost);
AbilityUseParams args = new AbilityUseParams(gameObject, null, player.WeaponSystem.BaseDamage);
ability.Use(args);
}
private void DealRadialDamage(AbilityUseParams args)
{
Collider[] colliders = Physics.OverlapSphere(args.self.transform.position, config.GetRadius());
foreach (Collider collider in colliders)
{
if (collider.gameObject == args.self)
{
continue;
}
var damageable = collider.GetComponent <Health>();
if (damageable != null)
{
damageable.TakeDamage(args.baseDamage + config.GetBonusDamage());
}
}
}
private void DealRadialDamage(AbilityUseParams useParams)
{
float damageToDeal = useParams.baseDamage + config.GetDamageToEachTarget();
//static sphere cast for targets around me
RaycastHit[] hits = Physics.SphereCastAll(transform.position, config.GetRadius(), Vector3.up, config.GetRadius());
int count = 0;
foreach (RaycastHit hit in hits)
{
var damageable = hit.collider.gameObject.GetComponent <IDamageable>();
var hitPlayer = hit.collider.gameObject.GetComponent <Player>();
if ((damageable != null) && (!hitPlayer))
{
damageable.TakeDamage(damageToDeal);
count++;
}
}
}
private void UseSpecialAbility(int index)
{
if (energy.IsEnergyAvailable(abilities[index].GetEnergyCost()) && IsAbilityAvailable(abilities[index]))
{
if (abilities[index].TargetSelf())
{
energy.UpdateEnergyPoints(abilities[index].GetEnergyCost());
var abilityParams = new AbilityUseParams(player, baseDamage, player);
abilities[index].Use(abilityParams);
abilities[index].lastHitTime = Time.time;
}
else if (WithinAbilityRange(abilities[index]))
{
energy.UpdateEnergyPoints(abilities[index].GetEnergyCost());
var abilityParams = new AbilityUseParams(currentEnemy, baseDamage, player);
abilities[index].Use(abilityParams);
abilities[index].lastHitTime = Time.time;
}
}
}
private void DealDamage(AbilityUseParams useParams)
{
print("AoE attack used by: " + gameObject.name);
Vector3 origin = gameObject.transform.position;
float radius = (config as AreaOfEffectConfig).GetRadius();
float damageAmount = useParams.baseDamage + (config as AreaOfEffectConfig).GetAbilityDamage();
RaycastHit[] targets = Physics.SphereCastAll(origin, radius, origin, radius);
// print("AoE Hit List: " + targets);
foreach (RaycastHit hit in targets)
{
var target = hit.collider.gameObject.GetComponent <IDamageable>();
// TODO: consider using Tag or layer, so enemies don't damage each other
if (target != null && target != useParams.user)
{
target.TakeDamage(damageAmount);
}
}
}
private void DealDamage(AbilityUseParams useParams)
{
print("BLAST attack used by: " + gameObject.name);
float damageAmount = useParams.baseDamage + (config as BlastAttackConfig).GetDamage();
float radius = (config as BlastAttackConfig).GetRadius();
float travelDistance = (config as BlastAttackConfig).GetTravel();
// TODO: get position of target - send to SphereCastAll
// Vector3 direction = useParams.target.gameObject.transform.position;
Vector3 origin = gameObject.transform.position;
// RaycastHit[] targets = Physics.SphereCastAll(origin, radius, direction, travelDistance);
// foreach (RaycastHit hit in targets)
// {
// var target = hit.collider.gameObject.GetComponent<IDamageable>();
// // TODO: consider using Tag or layer, so enemies don't damage each other
// if (target != null && target != useParams.user)
// {
// target.TakeDamage(damageAmount);
// }
// }
}
private void DealRadialDamage(AbilityUseParams useParams)
{
float damageToDeal = (config as AreaAttackConfig).DamageToEachTarget;
RaycastHit[] hits = Physics.SphereCastAll(
useParams.target.transform.position,
(config as AreaAttackConfig).DamageRadius,
Vector3.left,
(config as AreaAttackConfig).DamageRadius
);
foreach (RaycastHit hit in hits)
{
if (hit.collider && hit.collider.gameObject && hit.collider.gameObject != gameObject)
{
IDamageable damageableComponent = hit.collider.gameObject.GetComponent <IDamageable>();
if (damageableComponent != null)
{
damageableComponent.TakeDamage((config as AreaAttackConfig).DamageToEachTarget);
}
}
}
}
private void DealDamage(AbilityUseParams useParams)
{
MonoBehaviour newTarget = useParams.target as MonoBehaviour;
MonoBehaviour newUser = useParams.user as MonoBehaviour;
Vector3 destination = newTarget.gameObject.transform.position;
float speed = (config as ChargeAttackConfig).GetSpeed();
float damage = (config as ChargeAttackConfig).GetDamage();
float extraDamage = (config as ChargeAttackConfig).GetExtraDamage();
float radius = (config as ChargeAttackConfig).GetRadius();
var player = newUser.gameObject;
var target = newTarget.gameObject;
print(newTarget.transform.position);
print(newUser.transform.position);
// player.transform.position = target.transform.position;
// print("Charge attack used by: " + gameObject.name);
// Vector3 origin = gameObject.transform.position;
// float radius = (config as ChargeAttackConfig).GetRadius();
// float damageAmount = useParams.baseDamage + (config as ChargeAttackConfig).GetAbilityDamage();
// RaycastHit[] targets = Physics.SphereCastAll(origin, radius, origin, radius);
// // print("AoE Hit List: " + targets);
// foreach (RaycastHit hit in targets)
// {
// var target = hit.collider.gameObject.GetComponent<IDamageable>();
// // TODO: consider using Tag or layer, so enemies don't damage each other
// if (target != null && target != useParams.user)
// {
// target.TakeDamage(damageAmount);
// }
// }
}
abstract public void Use(AbilityUseParams args);
private void DoSelfHeal(AbilityUseParams useParams)
{
float pointsToHeal = config.GetHealingAmount();
player.Heal(pointsToHeal);
}
public void Use(AbilityUseParams useParams)
{
DoSelfHeal(useParams);
PlaySound();
PlayParticleEffect();
}
