private void CreateStatMod()
{
Debug.Log("Creating a stat mod : " + targetStat + " " + statAdjValue);
StatCollection.StatModifer mod = new StatCollection.StatModifer(statAdjValue, modType);
mods.Add(mod);
StatAdjustmentManager.ApplyTrackedStatMod(source, targetEntity, targetStat, mod);
}
void Awake()
{
if (statAdjustmentManager == null)
{
statAdjustmentManager = this;
}
else
{
Destroy(gameObject);
}
}
protected override void CleanUp()
{
int count = mods.Count;
for (int i = 0; i < count; i++)
{
Debug.Log("Cleaning durational stuff");
StatAdjustmentManager.RemoveTrackedStatMod(targetEntity, targetStat, mods[i]);
}
base.CleanUp();
}
protected override void CleanUp()
{
base.CleanUp();
if (permanent == false)
{
int count = mods.Count;
for (int i = 0; i < count; i++)
{
StatAdjustmentManager.RemoveTrackedStatMod(SourceEffect.ParentAbility.Source.GetStats(), Target.GetStats(), targetStat, mods[i], options);
}
}
}
private void CreateAndApplyStatMod()
{
if (permanent == false)
{
StatModifier mod = new StatModifier(adjValue, modType);
mods.Add(mod);
StatAdjustmentManager.ApplyTrackedStatMod(SourceEffect.ParentAbility.Source.GetStats(), Target.GetStats(), targetStat, mod, options);
}
else
{
StatAdjustmentManager.ApplyUntrackedStatMod(SourceEffect.ParentAbility.Source.GetStats(), Target.GetStats(), targetStat, adjValue, modType, options);
}
}
protected override void Tick()
{
base.Tick();
if (targetEntity != null)
{
StatAdjustmentManager.ApplyUntrackedStatMod(source, target.GetComponent <Entity>(), Constants.BaseStatType.Health, effectDamage);
//Debug.Log(effectDamage);
}
else
{
//Debug.Log("Target null");
}
}
public void InitializeAffectMovement(AffectMovementType type, float value, Vector2 knockback)
{
affectType = type;
amount = value;
//targetMovement = target.GetComponent<BaseMovement>();
switch (affectType)
{
case AffectMovementType.Halt:
//if (targetMovement == null)
// return;
//if (targetMovement is EntityMovement) {
// if (((EntityMovement)targetMovement).Grounded || ((EntityMovement)targetMovement).Platformed)
// target.GetComponent<Rigidbody2D>().velocity = Vector2.zero;
//}
//targetMovement.CanMove = false;
//targetMovement.CanPivot = false;
break;
case AffectMovementType.Knockback:
//target.GetComponent<Rigidbody2D>().velocity = Vector2.zero;
//targetMovement.CanMove = false;
//target.GetComponent<Rigidbody2D>().AddForce(knockback * value);
((MovingEntity)targetEntity).ModifyVelociy(knockback * value);
break;
case AffectMovementType.AlterSpeed:
mod = new StatCollection.StatModifer(amount, StatCollection.StatModificationType.Multiplicative);
//Debug.Log("Applyin a mod of " + mod.value);
StatAdjustmentManager.ApplyTrackedStatMod(source, targetEntity, StatCollection.BaseStat.BaseStatType.MoveSpeed, mod);
//CombatManager.ApplyUntrackedStatMod(source, target.GetComponent<Entity>(), Constants.BaseStatType.MoveSpeed, amount, StatCollection.StatModificationType.Multiplicative);
break;
case AffectMovementType.SuspendInAir:
((MovingEntity)targetEntity).ResetY();
break;
}
}
public bool CheckResourceValue(GameObject source)
{
bool result = false;
float resourceValue = source.Entity().EntityStats.GetStatModifiedValue(targetResource);
if (resourceValue >= resourceValueAmount)
{
result = true;
}
if (result == true && spendResource)
{
StatAdjustmentManager.ApplyUntrackedStatMod(source.Entity().EntityStats, source.Entity().EntityStats, targetResource, resourceValueAmount);
}
return(result);
}
private void HandlePenetration()
{
float penetrationCount = ProjectileStats.GetStatModifiedValue(BaseStat.StatType.ProjectilePenetration);
if (penetrationCount <= -1f)
{
return;
}
if (penetrationCount <= 0)
{
CleanUp();
}
else
{
StatAdjustmentManager.ApplyUntrackedStatMod(ProjectileStats, ProjectileStats, BaseStat.StatType.ProjectilePenetration, -1f);
}
}
protected override void CleanUp()
{
//if (targetMovement == null) {
// //Debug.Log("Nove moves");
// StatusManager.RemoveStatus(targetEntity, this);
// //Destroy(this);
// return;
//}
switch (affectType)
{
case AffectMovementType.Halt:
//targetMovement.CanMove = true;
//targetMovement.CanPivot = true;
break;
case AffectMovementType.AlterSpeed:
if (mod != null)
{
StatAdjustmentManager.RemoveTrackedStatMod(targetEntity, StatCollection.BaseStat.BaseStatType.MoveSpeed, mod);
}
else
{
Debug.Log("Mod NUll");
}
break;
case AffectMovementType.Knockback:
case AffectMovementType.SuspendInAir:
//targetMovement.CanMove = true;
((MovingEntity)targetEntity).ClearKnockbackVelocity();
break;
}
base.CleanUp();
}
protected override void CleanUp()
{
if (targetMovement == null)
{
//Debug.Log("Nove moves");
StatusManager.RemoveStatus(targetEntity, this);
//Destroy(this);
return;
}
switch (affectType)
{
case AffectMovementType.Halt:
targetMovement.CanMove = true;
targetMovement.CanPivot = true;
break;
case AffectMovementType.AlterSpeed:
if (mod != null)
{
StatAdjustmentManager.RemoveTrackedStatMod(targetEntity, Constants.BaseStatType.MoveSpeed, mod);
}
else
{
Debug.Log("Mod NUll");
}
break;
case AffectMovementType.Knockback:
targetMovement.CanMove = true;
break;
}
base.CleanUp();
}
public override void Apply(GameObject target)
{
float damage;
if (scaleFromBaseDamage)
{
damage = effectDamage + (parentAbility.source.stats.GetStatModifiedValue(Constants.BaseStatType.BaseDamage) * percentOfBaseDamage);
}
else
{
damage = effectDamage;
}
//Debug.Log(damage + " is being dealt to " + target.gameObject.name);
Entity targetEntity = target.GetComponent <Entity>();
if (targetEntity != null)
{
StatAdjustmentManager.ApplyUntrackedStatMod(Source, targetEntity, Constants.BaseStatType.Health, damage);
}
base.Apply(target);
}
public void RemoveMaxCharge(StatCollection source, StatModifier mod)
{
StatAdjustmentManager.RemoveTrackedStatMod(source, RecoveryStats, BaseStat.StatType.AbilityCharge, mod, StatCollection.StatModifierOption.Cap);
}
public void SpendCharge()
{
StatAdjustmentManager.ApplyUntrackedStatMod(RecoveryStats, RecoveryStats, BaseStat.StatType.AbilityCharge, -1f, StatModifier.StatModificationType.Additive);
}
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 ModifyCoolDown(StatCollection cause, StatModifier mod)
{
StatAdjustmentManager.ApplyTrackedStatMod(cause, Stats, BaseStat.StatType.CoolDown, mod);
}
protected void ApplyInstantStatAdjustment(GameObject target)
{
StatAdjustmentManager.ApplyUntrackedStatMod(ParentAbility.Source.GetStats(), target.GetStats(), adjInfo.targetStat, adjInfo.adjustmentValue, adjInfo.modType, adjInfo.options.ToArray());
}
