public void Init(AreaOfEffectSkill aoeSkill)
{
_aoeSkill = GeneralMethods.CopySkill(aoeSkill);
_skill = _aoeSkill;
if (_aoeSkill.Shape == AOEShape.Sphere)
{
var colliderToRemove = GetComponent <BoxCollider>();
if (colliderToRemove != null)
{
Destroy(colliderToRemove);
}
transform.localScale = new Vector3(_aoeSkill.Diameter, _aoeSkill.Diameter, _aoeSkill.Diameter);
}
else
{
var colliderToRemove = GetComponent <SphereCollider>();
if (colliderToRemove != null)
{
Destroy(colliderToRemove);
}
if (Rm_RPGHandler.Instance.Combat.AutomaticallyScaleAOE)
{
transform.localScale = new Vector3(_aoeSkill.Width, _aoeSkill.Height, _aoeSkill.Length);
}
}
Destroy(gameObject, aoeSkill.Duration);
_initialised = true;
//Debug.Log("Initialised skill");
}
public void Init(ProjectileSkill projSkill, BaseCharacterMono target, Vector3 targetPos = default(Vector3))
{
_projSkill = GeneralMethods.CopySkill(projSkill);
_skill = _projSkill;
_charTarget = target;
_direction = targetPos;
_baseHeight = transform.localScale.y / 2;
transform.position = transform.position + new Vector3(0, _baseHeight, 0);
if (projSkill.CasterMono != null)
{
var spawnPosition = projSkill.CasterMono.GetComponentInChildren <ProjectileSpawnPosition>();
if (spawnPosition != null)
{
transform.position = spawnPosition.transform.position;
}
}
if (targetPos != Vector3.zero)
{
transform.LookAt(new Vector3(targetPos.x, transform.position.y, targetPos.z));
}
else if (target != null)
{
transform.LookAt(target.transform.position);
}
else
{
Destroy(gameObject);
return;
}
if (_projSkill.TravelSound.Audio != null)
{
var sound = AudioPlayer.Instance.Play(_projSkill.TravelSound.Audio, AudioType.SoundFX, transform.position, transform);
sound.GetComponent <AudioSource>().loop = true;
sound.AddComponent <DestroyHelper>().Init(DestroyCondition.GameObjectIsNull, gameObject);
}
//todo: projectile radius: transform.localScale = new Vector3(_projSkill.Diameter, _projSkill.Diameter, _projSkill.Diameter);
Destroy(gameObject, projSkill.TimeTillDestroy);
_initialised = true;
//Debug.Log("Initialised skill");
}
public void Init(Skill spawnSkill, BaseCharacterMono target)
{
if (spawnSkill.LimitSpawnInstances)
{
if (SpawnedObjectInstanceTracker.ContainsKey(spawnSkill.ID))
{
var currentInstances = SpawnedObjectInstanceTracker[spawnSkill.ID];
if (currentInstances < spawnSkill.MaxInstances)
{
SpawnedObjectInstanceTracker[spawnSkill.ID] += 1;
}
else
{
Debug.Log("Max instances of this spawn reached.");
Destroy(gameObject);
return;
}
}
else
{
SpawnedObjectInstanceTracker.Add(spawnSkill.ID, 1);
}
}
_spawnSkill = GeneralMethods.CopySkill(spawnSkill);
_charTarget = target;
transform.position = transform.position + new Vector3(0, transform.localScale.y / 2, 0);
if (spawnSkill.HasDuration)
{
Destroy(gameObject, spawnSkill.SpawnForTime);
}
//LoadAllData();
_initialised = true;
Debug.Log("Initialised skill");
}
protected void CastSkill(Skill originalSkill, BaseCharacterMono target, Vector3?nullableTargetPos)
{
if (originalSkill.SkillType == SkillType.Area_Of_Effect || originalSkill.SkillType == SkillType.Spawn)
{
if (nullableTargetPos == null)
{
if (target != null)
{
nullableTargetPos = target.transform.position;
target = null;
}
}
}
if (target == null && !nullableTargetPos.HasValue)
{
return;
}
if (target != null && !target.Character.Alive)
{
return;
}
var hasCharacterTarget = target != null;
var targetPos = nullableTargetPos.GetValueOrDefault();
if (hasCharacterTarget)
{
HandleSkillOnTarget(originalSkill, target);
}
else
{
var skillToUse = GeneralMethods.CopySkill(originalSkill);
var newTargetPos = targetPos;
if (skillToUse.SkillType == SkillType.Area_Of_Effect)
{
var aoeSkill = (AreaOfEffectSkill)skillToUse;
newTargetPos = targetPos + new Vector3(0, aoeSkill.Height / 2, 0);
var skillPrefab = GeneralMethods.SpawnPrefab(aoeSkill.PrefabPath, newTargetPos, Quaternion.identity, null);
skillPrefab.GetComponent <AreaOfEffectSkillHandler>().Init(aoeSkill);
}
else if (skillToUse.SkillType == SkillType.Projectile)
{
var projSkill = (ProjectileSkill)skillToUse;
var projectilePosition = targetPos;
var casterTransform = transform;
newTargetPos = casterTransform.position + (casterTransform.up * 1.3f);
var skillPrefab = GeneralMethods.SpawnPrefab(skillToUse.PrefabPath, newTargetPos, Quaternion.identity, null);
skillPrefab.GetComponent <ProjectileSkillHandler>().Init(projSkill, null, projectilePosition);
}
else if (skillToUse.SkillType == SkillType.Spawn)
{
var spawnSkill = skillToUse;
newTargetPos = targetPos + new Vector3(0, 1, 0);
var skillPrefab = GeneralMethods.SpawnPrefab(skillToUse.PrefabPath, newTargetPos, Quaternion.identity, null);
skillPrefab.GetComponent <SpawnSkillHandler>().Init(spawnSkill, target);
}
}
}
private void HandleSkillOnTarget(Skill originalSkill, BaseCharacterMono target)
{
var skillToUse = GeneralMethods.CopySkill(originalSkill);
//Debug.Log("Handled skill hit for " + target.Character.Name);
if (skillToUse.Caster != null)
{
DamageOutcome outcome = new DamageOutcome(new Damage(), AttackOutcome.Success);
var damageToDeal = skillToUse.Damage;
if (damageToDeal.MaxTotal > 0)
{
var projSkillHandler = this as ProjectileSkillHandler;
if (projSkillHandler != null)
{
var projSkill = (ProjectileSkill)_skill;
if (projSkill.IsPiercing)
{
damageToDeal.ApplyMultiplier(projSkill.PiercingScaling[projSkillHandler.PierceCounter]);
}
}
if (skillToUse.CasterMono != null)
{
outcome = skillToUse.CasterMono.Controller.RPGCombat.DamageTarget(target, damageToDeal);
var cc = target.Character as CombatCharacter;
if (cc != null)
{
var targetTaunt = cc.TauntHandler;
if (!targetTaunt.Tracker.ContainsKey(skillToUse.CasterMono))
{
targetTaunt.Tracker.Add(skillToUse.CasterMono, 1);
}
targetTaunt.Tracker[skillToUse.CasterMono] += skillToUse.BonusTaunt;
}
}
else
{
outcome = target.Character.VitalHandler.TakeDamage(skillToUse.Caster, damageToDeal);
}
}
var onCritProcs = new List <Rm_ProcEffect>();
var onHitProcs = new List <Rm_ProcEffect>();
var procs = skillToUse.Caster.ProcEffects;
if (skillToUse.HasProcEffect)
{
switch (skillToUse.ProcEffect.ProcCondition)
{
case Rm_ProcCondition.Every_N_Hits:
case Rm_ProcCondition.Chance_On_Hit:
case Rm_ProcCondition.On_Hit:
onHitProcs.Add(skillToUse.ProcEffect);
break;
case Rm_ProcCondition.Chance_On_Critical_Hit:
onCritProcs.Add(skillToUse.ProcEffect);
break;
}
}
foreach (var procEffect in procs)
{
switch (procEffect.ProcCondition)
{
case Rm_ProcCondition.Every_N_Hits:
case Rm_ProcCondition.Chance_On_Hit:
case Rm_ProcCondition.On_Hit:
onHitProcs.Add(procEffect);
break;
case Rm_ProcCondition.Chance_On_Critical_Hit:
onCritProcs.Add(procEffect);
break;
}
}
if (damageToDeal.MaxTotal == 0 || outcome != null && (outcome.AttackOutcome == AttackOutcome.Success || outcome.AttackOutcome == AttackOutcome.Critical))
{
foreach (var proc in onHitProcs)
{
IncrementSkillCounters(skillToUse);
HandleProc(proc, target);
}
if (skillToUse.ApplyDOTOnHit)
{
var canApply = Random.Range(0, 100 + 1) <= (int)(skillToUse.ChanceToApplyDOT * 100);
if (canApply)
{
skillToUse.DamageOverTime.SkillMetaID = skillToUse.SkillMetaID;
skillToUse.DamageOverTime.Attacker = skillToUse.Caster;
target.Character.AddDoT(skillToUse.DamageOverTime);
}
}
if (skillToUse.RunEventOnHit)
{
if (!string.IsNullOrEmpty(skillToUse.EventOnHitID))
{
Debug.Log("Not implemented: do event:" + skillToUse.EventOnHitID);
}
}
if (skillToUse.SkillType == SkillType.Aura)
{
var auraSkill = (AuraSkill)skillToUse;
target.Character.ToggleAura(auraSkill, true);
}
else if (skillToUse.SkillType == SkillType.Restoration)
{
var restoSkill = (RestorationSkill)skillToUse;
target.Character.AddRestoration(restoSkill.Restoration);
}
if (skillToUse.AppliesBuffDebuff)
{
target.Character.AddTimedPassiveEffect(skillToUse.Effect);
}
if (skillToUse.ApplyStatusEffect)
{
var apply = Random.Range(0, 100 + 1) <= (int)(skillToUse.ChanceToApplyStatusEffect * 100);
if (apply)
{
var statusEffect = Rm_RPGHandler.Instance.Repositories.StatusEffects.Get(skillToUse.StatusEffectID);
if (statusEffect != null)
{
statusEffect.Effect.HasDuration = skillToUse.ApplyStatusEffectWithDuration;
if (statusEffect.Effect.HasDuration)
{
statusEffect.Effect.Duration = skillToUse.ApplyStatusEffectDuration;
}
target.Character.AddStatusEffect(statusEffect);
}
}
}
if (skillToUse.RemoveStatusEffect)
{
var apply = Random.Range(0, 100 + 1) <= (int)(skillToUse.ChanceToRemoveStatusEffect * 100);
if (apply)
{
target.Character.RemoveStatusEffect(skillToUse.RemoveStatusEffectID);
}
}
var impact = GeneralMethods.SpawnPrefab(skillToUse.ImpactPrefabPath, target.transform.position, Quaternion.identity, target.transform);
if (impact != null)
{
impact.GetComponent <DestroyHelper>().Init(DestroyCondition.Time, 0.3f);
}
AudioPlayer.Instance.Play(skillToUse.ImpactSound.Audio, AudioType.SoundFX, target.transform.position, target.transform);
}
if (outcome != null && outcome.AttackOutcome == AttackOutcome.Critical)
{
foreach (var proc in onCritProcs)
{
IncrementSkillCounters(skillToUse);
HandleProc(proc, target);
}
}
}
}
