private void Aim()
{
if (CurrentTarget == null)
{
State = LookState.AquiringTarget;
return;
}
transform.rotation = TargetingUtilities.SmoothRotation(CurrentTarget.position, transform, rotateSpeed, error);
}
//private void AquireTarget() {
// alltargets = TargetingUtilities.FindAllTargets(transform.position, detectionRadius, targetLayer);
// CurrentTarget = TargetingUtilities.FindNearestTarget(transform.position, alltargets);
// if (CurrentTarget != null)
// State = LookState.Aiming;
//}
protected virtual void Aim()
{
AquireTarget();
if (targetPos != Vector2.zero)
{
transform.rotation = TargetingUtilities.SmoothRotation(targetPos, transform, rotateSpeed, error);
}
}
private void AquireTarget()
{
alltargets = TargetingUtilities.FindAllTargets(transform.position, detectionRadius, targetLayer);
CurrentTarget = TargetingUtilities.FindNearestTarget(transform.position, alltargets);
if (CurrentTarget != null)
{
State = LookState.Aiming;
}
}
private void CreateHitEffects(RaycastHit2D hit)
{
Vector2 rayDir = Vector2.Reflect((hit.point - effectOrigin).normalized, hit.normal);
Quaternion impactRotation = TargetingUtilities.CalculateImpactRotation(rayDir);
GameObject hitPrefab = Resources.Load(((EffectAttack)parentEffect).impactEffectName) as GameObject;
GameObject hitEffect = VisualEffectManager.CreateVisualEffect(hitPrefab, hit.point, impactRotation);
VisualEffectManager.SetParticleEffectLayer(hitEffect, hit.collider.gameObject);
//ParticleSystem[] ps = hitEffect.GetComponentsInChildren<ParticleSystem>();
//SpriteRenderer hitSprite = hit.collider.gameObject.GetComponentInChildren<SpriteRenderer>();
//for (int i = 0; i < ps.Length; i++) {
// ps[i].GetComponent<ParticleSystemRenderer>().sortingOrder = hitSprite.sortingOrder;
//}
}
public override void Initialize()
{
base.Initialize();
UpdateBaseStats();
if (lobbed)
{
direction = Direction.None;
Vector2 lobDirection = TargetingUtilities.DegreeToVector2(angle);
if (parentProjectile.ParentFacing == Constants.EntityFacing.Left)
{
lobDirection = new Vector2(-lobDirection.x, lobDirection.y);
}
myBody.AddForce(lobDirection * maxSpeed);
}
}
public override void Apply(GameObject target)
{
base.Apply(target);
//if (!CheckForSpecificTarget(target))
// return;
switch (statusType)
{
case Constants.StatusEffectType.None:
//Status newStatus = target.AddComponent<Status>();
Status newStatus = new Status();
newStatus.Initialize(target, duration, interval, statusType, parentAbility);
StatusManager.AddStatus(target.GetComponent <Entity>(), newStatus, this, parentAbility);
break;
case Constants.StatusEffectType.AffectMovement:
//AffectMovement newAffectMovement = target.AddComponent<AffectMovement>();
AffectMovement newAffectMovement = new AffectMovement();
//knockbackVector = TargetingUtilities.DegreeToVector2(knocbackAngle);
knockbackVector = TargetingUtilities.DirectionFromAngle(knocbackAngle, false);
if (Source.Facing == Constants.EntityFacing.Left)
{
knockbackVector = new Vector2(-knockbackVector.x, knockbackVector.y);
}
//Debug.Log(knockbackVector + " is the knockback vector");
newAffectMovement.Initialize(target, duration, interval, statusType, parentAbility, maxStack, onCompleteEffect);
newAffectMovement.InitializeAffectMovement(affectMoveType, affectMoveValue, knockbackVector);
StatusManager.AddStatus(target.GetComponent <Entity>(), newAffectMovement, this, parentAbility);
break;
case Constants.StatusEffectType.Stun:
Stun newStun = new Stun();
newStun.Initialize(target, duration, interval, statusType, parentAbility);
newStun.InitializeStun();
StatusManager.AddStatus(target.GetComponent <Entity>(), newStun, this, parentAbility);
break;
case Constants.StatusEffectType.DamageOverTime:
float damage;
if (scaleFromBaseDamage)
{
damage = damagePerInterval + (parentAbility.source.stats.GetStatModifiedValue(StatCollection.BaseStat.BaseStatType.BaseDamage) * percentOfBaseDamage);
}
else
{
damage = damagePerInterval;
}
//DamageOverTime newDot = target.AddComponent<DamageOverTime>();
DamageOverTime newDot = new DamageOverTime();
newDot.Initialize(target, duration, interval, statusType, parentAbility, maxStack);
newDot.InitializeDamageOverTime(damage, parentAbility.source);
StatusManager.AddStatus(target.GetComponent <Entity>(), newDot, this, parentAbility);
Debug.Log("Applying " + damage + " over time");
break;
case Constants.StatusEffectType.StaticStatAdjustment:
StatCollection.StatModifer modStatic = new StatCollection.StatModifer(statAdjustmentValue, modType);
Debug.Log("Stat " + statType + " is being adjusted by " + statAdjustmentValue);
StatAdjustmentManager.ApplyTrackedStatMod(Source, target.GetComponent <Entity>(), statType, modStatic);
break;
case Constants.StatusEffectType.DurationalStatAdjustment:
//StatCollection.StatModifer modDur = new StatCollection.StatModifer(statAdjustmentValue, modType);
Debug.Log("Setting durational stuff");
DurationalStatChange newDurationalStatChange = new DurationalStatChange();
newDurationalStatChange.Initialize(target, duration, interval, statusType, parentAbility, maxStack);
newDurationalStatChange.InitializeDurationalStatChange(statType, modType, statAdjustmentValue);
StatusManager.AddStatus(target.GetComponent <Entity>(), newDurationalStatChange, this, parentAbility);
break;
}
}
public void TargetDelay()
{
transform.rotation = TargetingUtilities.SmoothRotation(randomDirection, transform, rotateSpeed, error);
}
