void HitAndExplode(Effectable effectable)
{
int damage = Data.damageRange.RandomDamage();
effectable?.ApplyDamage(damage);
effectable?.ApplyExplosion(5f);
}
void OnPosReachedAttack(Effectable ef, Vector2 targetPos)
{
if (positionReached)
{
onPosReachedAttack?.Invoke(ef, targetPos);
}
}
public override void Attack(Effectable singleTarget, Vector2 SingleTargetPosition)
{
foreach (var ab in AoeBehaviors)
{
ab.StartAOEBehavior();
}
}
public override async void AttackFunction(Effectable singleTarget,
Vector2 SingleTargetPosition)
{
int counter = NumOfProjectiles;
float timeCounter = 0;
if (AsyncAttackInProgress == false)
{
AsyncAttackInProgress = true;
while (counter >= 0)
{
if (timeCounter <= 0)
{
GenericProjectile proj = projectilePool.GetInactive();
var transform = proj.transform;
transform.position = ProjectileExitPoints[0].transform.position;
transform.rotation = ProjectileExitPoints[0].transform.rotation;
proj.TargetPosition = ProjectileFinalPoints[0].transform.position; //can also be projectile final point position
proj.EffectableTarget = singleTarget ?? null;
proj.Activate();
timeCounter = timebetweenProjectiles;
counter -= 1;
}
timeCounter -= StaticObjects.DeltaGameTime;
await Task.Yield();
}
AsyncAttackInProgress = false;
}
}
public override void Execute(Effectable actor)
{
Unit defUnit = (actor as Unit);
Damage = DamageCalculation.GetDamage(atkUnit, defUnit, hitAdd, atkMult, atkAdd, friendly);
defUnit.TakeDamage(Damage);
}
public override bool AddEffect(Effectable eff)
{
if (eff.gameObject.CompareTag("Fire"))
{
eff.effects.Remove(this);
}
return(true);
}
public void Clear()
{
if (EffectableTarget != null)
{
EffectableTarget = null;
}
TargetPosition = nowhere;
}
public void RemovePlayerUnitTarget(string unitName, string callerName)
{
if (PlayerTarget?.name == unitName)
{
PlayerTarget = null;
EffectableTarget = null;
}
RemoveUnitFromPlayerUnitsFightingDictionary(unitName);
}
public override void Execute(Effectable actor)
{
Unit unit = (actor as Unit);
if (unit != null)
{
Debug.Log(actor + " was killed");
unit.Die();
}
}
private void ApplyEffectOnMainTarget(Effectable ef, Vector2 targetPos)
{
if (TargetBank.Targets.ContainsKey(ef.name))
{
if (ef.IsTargetable())
{
onMainTargetEffect?.Invoke(ef, targetPos);
}
}
}
public override bool ShouldPickup(Effectable eff)
{
var res = eff.GetComponent <Entities.Character.Player>();
if (res != null)
{
return(true);
}
return(false);
}
public override bool ShouldPickup(Effectable eff)
{
var res = eff.GetComponent <Resources>();
if (res != null)
{
return(true);
}
return(false);
}
public void Apply(Effectable actor)
{
foreach (Effect effect in EnemyEffects)
{
(actor as Unit).AddEffect(effect);
}
foreach (Effect effect in SelfEffects)
{
AbilityUser.AddEffect(effect);
}
lastUsed = 0;
}
private void OnHitEffects(Effectable eff, Resources res)
{
foreach (Effect e in eff.effects)
{
if (e == this)
{
continue;
}
e.OnHit(eff, res);
}
}
public override void Apply(Effectable ef, Vector2 targetPos)
{
EffectableUnit efu = ef as EffectableUnit;
if (efu.unitController != null)
{
if (somePrefab != null)
{
GameObject someGo = GameObject.Instantiate(somePrefab);
}
}
}
public override bool AddEffect(Effectable eff)
{
var res = eff.GetComponent <Entities.Character.Player>();
if (res != null)
{
var amount = GameManager.Instance.rand.RandomIntInRange(minMaxAmount.x, minMaxAmount.y);
res.maxBombs += amount;
}
eff.effects.Remove(this);
return(true);
}
public override bool AddEffect(Effectable eff)
{
var res = eff.GetComponent <Resources>();
if (res != null)
{
var amount = GameManager.Instance.rand.RandomIntInRange(minMaxAmount.x, minMaxAmount.y);
res.maxHealth += amount;
res.Health = res.maxHealth;
}
eff.effects.Remove(this);
return(true);
}
public override bool OnSpawn(Effectable eff)
{
foreach (Effect e in eff.effects)
{
var td = e as TouchDamage;
if (td != null)
{
td.destroyOnTouch = false;
return(true);
}
}
return(false);
}
public override bool PerTick(Effectable eff)
{
var dt = Time.deltaTime;
foreach (Effect e in eff.effects)
{
e.ChangeTime(eff, ref dt);
}
time += dt;
if (time < delayBetween)
{
return(false);
}
time = 0;
var effectsToTransfer = eff.GetEffectSublist(1);
effectsToTransfer.Remove(this);
for (int i = effectsToTransfer.Count - 1; i >= 0; i--)
{
if (effectsToTransfer[i] is SpawnProjectileConstant)
{
effectsToTransfer.RemoveAt(i);
}
}
for (int i = 0; i < number; i++)
{
var angle = Mathf.PI / 4 + (i / (float)number) * 2 * Mathf.PI;
var velocity = new Vector2(Mathf.Cos(angle), Mathf.Sin(angle));
var spawned = Instantiate(spawnOnHit);
var newProj = spawned.GetComponent <Projectile>();
if (newProj != null)
{
newProj.AddEffects(effectsToTransfer);
newProj.doNotHit = eff.GetComponent <Resources>();
newProj.doNotHitLayers = eff.gameObject.layer;
newProj.SetVelocity(velocity * speed);
}
spawned.transform.parent = GameManager.Instance.holder.transform;
newProj.transform.position = eff.transform.position + new Vector3(velocity.x, velocity.y, 0) * 0.1f;
}
return(true);
}
public override async void AttackFunction(Effectable singleTarget, Vector2 SingleTargetPosition)
{
if (AsyncAttackInProgress == false)
{
AsyncAttackInProgress = true;
GenericProjectile proj = projectilePool.Get();
var transform = proj.transform;
transform.rotation = ProjectileExitPoints[0].transform.rotation;
transform.position = ProjectileExitPoints[0].transform.position;
proj.TargetPosition = ProjectileFinalPoints[0].transform.position; // can also be projectile final point position
proj.EffectableTarget = singleTarget ?? null;
proj.Activate();
AsyncAttackInProgress = false;
}
}
public override bool PerTick(Effectable eff)
{
float curScale = scale;
if (addOthers)
{
foreach (Effect e in eff.effects)
{
e.ChangeRange(eff, ref curScale);
}
}
eff.transform.localScale = new Vector3(curScale, curScale, curScale);
return(base.PerTick(eff));
}
public void Hit(Effectable eff)
{
var effectsToTransfer = eff.GetEffectSublist(1);
effectsToTransfer.Remove(this);
var spawned = GameObject.Instantiate(spawnOnHit);
var newEff = spawned.GetComponent <Effectable>();
if (newEff != null)
{
newEff.AddEffects(effectsToTransfer);
newEff.doNotHit = eff.GetComponent <Resources>();
}
spawned.transform.position = eff.transform.position;
spawned.transform.parent = GameManager.Instance.holder.transform;
}
public override bool AddEffect(Effectable eff)
{
bool found = false;
foreach (Effect e in eff.effects)
{
if (e is TouchDamage && e != this)
{
(e as TouchDamage).damage += this.damage;
found = true;
}
}
if (found)
{
eff.effects.Remove(this);
}
return(true);
}
public override void Execute(Effectable actor)
{
Unit unit = (actor as Unit);
switch (stat)
{
case Stat.Atk:
unit.Attack += amount;
break;
case Stat.Spd:
unit.MoveSpeed += amount;
break;
case Stat.InjMul:
unit.InjuryMultiplier += amount / 100;
break;
}
Debug.Log((actor as Unit) + "has gained " + amount + " to " + stat);
}
public void ApplyEffectsOnTargets()
{
int counter = 0;
Effectable[] targets = new Effectable[TargetBank.Targets.Count];
foreach (KeyValuePair <string, (Effectable, bool)> item in TargetBank.Targets)
{
if (item.Value.Item1 != null)
{
targets[counter] = item.Value.Item1;
counter += 1;
}
}
for (int i = 0; i < targets.Length; i++)
{
if (targets[i] != null)
{
OnApplyEffect(targets);
}
}
}
public override bool PerTick(Effectable eff)
{
var dt = Time.deltaTime;
foreach (Effect e in eff.effects)
{
e.ChangeTime(eff, ref dt);
}
time += dt;
if (time > fireTime)
{
time = 0;
var spawned = GameObject.Instantiate(firePrefab);
spawned.transform.position = eff.transform.position;
spawned.transform.parent = GameManager.Instance.holder.transform;
var proj = spawned.GetComponent <Effectable>();
if (proj != null)
{
var effectsToTransfer = eff.GetEffectSublist(1);
for (int i = effectsToTransfer.Count - 1; i >= 0; i--)
{
if (effectsToTransfer[i] is FireOnTick)
{
effectsToTransfer.RemoveAt(i);
}
}
proj.AddEffects(eff.GetEffectSublist(1));
proj.doNotHit = eff.GetComponent <Resources>();
}
return(true);
}
return(false);
}
public void AddTestData()
{
Creatables.Add(new TestCreatable
{
Id = Guid.Empty
});
Modifiables.Add(new TestModifiable
{
Id = Guid.Empty
});
Deletable.Add(new TestDeletable
{
Id = Guid.Empty
});
Effectable.Add(new TestEffectable
{
Id = Guid.Empty
});
Ownable.Add(new TestOwnable
{
Id = Guid.Empty
});
SaveChanges();
}
public override bool PerTick(Effectable eff)
{
if (collider == null)
{
collider = eff.GetComponent <Collider2D>();
}
if (collider == null)
{
return(false);
}
var num = collider.OverlapCollider(filter, results);
bool hasHit = false;
for (int i = 0; i < num; i++)
{
if (results[i].gameObject.layer == eff.doNotHitLayers)
{
continue;
}
if (results[i].gameObject == eff.gameObject)
{
continue;
}
if (results[i].gameObject.transform.position.z > 1)
{
continue;
}
var res = results[i].GetComponent <Resources>();
if (res != null && res != eff.doNotHit)
{
float curDamage = damage;
foreach (Effect e in eff.effects)
{
e.ChangeStrength(eff, ref curDamage);
}
if (res.Damage((int)curDamage))
{
hasHit = true;
if (eff is Projectile)
{
var proj = eff as Projectile;
OnHitEffects(proj, -proj.GetVelocity(), res);
}
else
{
OnHitEffects(eff, res);
}
}
}
}
if (hasHit && destroyOnTouch)
{
eff.Destroy();
}
return(hasHit);
}
public async void Attack(Effectable singleTarget,
Vector2 singleTargetPosition)
{
onAttack?.Invoke();
AttackFunction(singleTarget, singleTargetPosition);
}
public abstract void AttackFunction(Effectable singleTarget,
Vector2 SingleTargetPosition);
