public override void OnAttack(AttackInfo ai)
{
m_attack.RemoveResistence(physResist);
m_attack.RemoveResistence(lightningResist);
physResist = null;
m_attack.CanTarget = true;
}
void TakeDoT(HitboxDoT hbdot)
{
Resistence r = GetAverageResistences(hbdot.Element);
float d = hbdot.Damage - (hbdot.Damage * (r.Percentage / 100f));
DamageObj(d * ScaledTime.deltaTime);
if (Health <= 0f)
{
Killer = hbdot.Creator;
}
if (hbdot.IsFixedKnockback)
{
Vector2 kb = hbdot.Knockback - (hbdot.Knockback * Mathf.Min(1f, (r.KnockbackResist / 100f)));
if (GetComponent <BasicPhysics>() != null)
{
GetComponent <BasicPhysics>().AddToVelocity(kb * ScaledTime.deltaTime);
}
}
else
{
Vector3 otherPos = gameObject.transform.position;
float angle = Mathf.Atan2(transform.position.y - otherPos.y, transform.position.x - otherPos.x); //*180.0f / Mathf.PI;
float magnitude = hbdot.Knockback.magnitude;
float forceX = Mathf.Cos(angle) * magnitude;
float forceY = Mathf.Sin(angle) * magnitude;
Vector2 force = new Vector2(-forceX, -forceY);
if (GetComponent <BasicPhysics>() != null)
{
GetComponent <BasicPhysics>().AddToVelocity(force * ScaledTime.deltaTime);
}
}
}
private void ApplyHitToPhysicsSS(Hitbox hb)
{
Resistence r = GetAverageResistences(hb.Element);
Vector2 kb = hb.Knockback - (hb.Knockback * Mathf.Min(1f, (r.KnockbackResist / 100f)));
if (!m_movementController)
{
return;
}
if (hb.IsFixedKnockback)
{
m_movementController.AddToVelocity(kb);
return;
}
Vector3 hitVector = transform.position - hb.transform.position;
float angle = Mathf.Atan2(hitVector.y, hitVector.x); //*180.0f / Mathf.PI;
Vector2 force = new Vector2(Mathf.Cos(angle), Mathf.Sin(angle));
force.Scale(new Vector2(kb.magnitude, kb.magnitude));
float counterF = m_movementController.Velocity.y * (1 / Time.deltaTime);
if (counterF < 0)
{
force.y = force.y - counterF;
}
m_movementController.AddToVelocity(force);
}
private Resistence GetAverageResistences(List <ElementType> le)
{
Resistence newR = new Resistence();
int numResists = 0;
foreach (ElementType et in le)
{
Resistence pr = GetResistence(et);
newR.Percentage += pr.Percentage;
newR.KnockbackResist += pr.KnockbackResist;
newR.StunResist += pr.StunResist;
numResists++;
}
if (numResists > 0)
{
newR.Percentage /= numResists;
newR.KnockbackResist /= numResists;
newR.StunResist /= numResists;
}
else
{
newR.Percentage = 0f;
newR.KnockbackResist = 0f;
newR.StunResist = 0f;
}
return(newR);
}
// Use this for initialization
public override void OnAddProperty()
{
physResist = GetComponent <Attackable>().AddResistence(ElementType.PHYSICAL, 100.0f, false, false, 0f, 100f, 100f);
fireResist = GetComponent <Attackable>().AddResistence(ElementType.FIRE, 100.0f, false, false, 0f, 100f, 100f);
elecResist = GetComponent <Attackable>().AddResistence(ElementType.LIGHTNING, 100.0f, false, false, 0f, 100f, 100f);
bioResist = GetComponent <Attackable>().AddResistence(ElementType.BIOLOGICAL, 100.0f, false, false, 0f, 100f, 100f);
psyResist = GetComponent <Attackable>().AddResistence(ElementType.PSYCHIC, 100.0f, false, false, 0f, 100f, 100f);
}
public Resistence AddResistence(ElementType element, float percentage, bool overflow = false, bool isTimed = false, float duration = 0f,
float resistStun = 0f, float resistKnockback = 0f)
{
Resistence r = newResist(element, percentage, overflow, isTimed, duration, resistStun, resistKnockback);
AddResistence(r);
return(r);
}
public override void OnAddProperty()
{
m_attack = GetComponent <Attackable> ();
m_fight = GetComponent <Fighter> ();
Debug.Log("Setting Faction Type");
physResist = m_attack.AddResistence(ElementType.PHYSICAL, 100.0f, false, false, 0f, 100.0f, 100.0f);
lightningResist = m_attack.AddResistence(ElementType.LIGHTNING, 100.0f, false, false, 0f, 100.0f, 100.0f);
m_oldCanTarget = m_attack.CanTarget;
m_attack.CanTarget = false;
}
public HitResult TakeHit(HitInfo hi)
{
ExecuteEvents.Execute <ICustomMessageTarget> (gameObject, null, (x, y) => x.OnHit(hi, hi.Creator));
HitboxDoT hd = hi.mHitbox as HitboxDoT;
if (hd != null)
{
TakeDoT(hd);
return(HitResult.NONE);
}
if (GetComponent <AIBase>())
{
GetComponent <AIBase> ().OnHit(hi);
}
Resistence r = GetAverageResistences(hi.Element);
float d;
//Debug.Log ("Damage; " + hi.Damage + " r: " + r.Percentage);
d = hi.Damage - (hi.Damage * (r.Percentage / 100f));
float fD = hi.FocusDamage;
d = DamageObj(d);
ApplyHitToPhysicsSS(hi);
float s = hi.Stun - (hi.Stun * Mathf.Min(1f, (r.StunResist / 100f)));
if (hi.Stun > 0f && m_fighter)
{
if (s <= 0f)
{
return(HitResult.BLOCKED);
}
m_fighter.RegisterStun(s, true, hi, (d >= 0f && fD >= 0f));
}
if (Health <= 0f)
{
Killer = hi.Creator;
}
if (d == 0f && fD == 0f)
{
return(HitResult.NONE);
}
else if (d < 0f)
{
return(HitResult.HIT);
}
else if (fD >= 0f)
{
return(HitResult.FOCUSHIT);
}
else
{
return(HitResult.HEAL);
}
}
// Start is called before the first frame update
public override void OnUpdate()
{
if (m_attack != null && m_fight != null &&
!m_fight.IsAttacking() && m_fight.StunTime <= 0f)
{
if (physResist == null)
{
physResist = m_attack.AddResistence(ElementType.PHYSICAL, 100.0f, false, false, 0f, 100.0f, 100.0f);
lightningResist = m_attack.AddResistence(ElementType.LIGHTNING, 100.0f, false, false, 0f, 100.0f, 100.0f);
m_attack.CanTarget = false;
}
}
}
public override void OnAddProperty()
{
physResist = GetComponent <Attackable>().AddResistence(ElementType.PHYSICAL, 25.0f, false, false, 0.0f, 70.0f, 70.0f);
fireResist = GetComponent <Attackable>().AddResistence(ElementType.FIRE, 100.0f, false, false, 0.0f, 0.0f, 100.0f);
lightningResist = GetComponent <Attackable>().AddResistence(ElementType.LIGHTNING, -25.0f, false, false, 0.0f, -25.0f, 100.0f);
if (GetComponent <BasicMovement> () != null)
{
GetComponent <BasicMovement> ().SetMoveSpeed(GetComponent <BasicMovement> ().MoveSpeed / 1.25f);
GetComponent <BasicMovement> ().SetJumpData(GetComponent <BasicMovement> ().JumpHeight / 1.5f, GetComponent <BasicMovement> ().TimeToJumpApex);
}
fx = GetComponent <PropertyHolder> ().AddBodyEffect(FXBody.Instance.FXIron);
// GetComponent<PhysicsSS>().SetGravityScale(-2.0f);
}
public void ClearResistence(ElementType element)
{
foreach (Resistence r in Resistences)
{
if (r.Element == element)
{
Resistences.Remove(r);
}
}
Resistence re = new Resistence();
re.Element = element;
m_fullResistences[element] = re;
}
private Resistence newResist(ElementType element, float percentage, bool overflow = false, bool isTimed = false, float duration = 0f,
float resistStun = 0f, float resistKnockback = 0f)
{
Resistence r = new Resistence();
r.Element = element;
r.Percentage = percentage;
r.Duration = duration;
r.StunResist = resistStun;
r.KnockbackResist = resistKnockback;
r.Timed = isTimed;
r.AvoidOverflow = overflow;
return(r);
}
internal void InitResistences()
{
m_fullResistences.Clear();
for (int i = 0; i < 5; i++)
{
Resistence r = new Resistence();
r.Element = (ElementType)i;
m_fullResistences.Add((ElementType)i, r);
}
foreach (Resistence r in Resistences)
{
AddResistence(r);
}
AddResistence(ElementType.BIOLOGICAL, 100f, false, false);
}
public HitResult TakeHit(Hitbox hb)
{
ExecuteEvents.Execute <ICustomMessageTarget> (gameObject, null, (x, y) => x.OnHit(hb, hb.Creator));
HitboxDoT hd = hb as HitboxDoT;
if (hd != null)
{
TakeDoT(hd);
return(HitResult.NONE);
}
if (GetComponent <AIFighter>())
{
GetComponent <AIFighter> ().OnHit(hb);
}
Resistence r = GetAverageResistences(hb.Element);
float d;
d = hb.Damage - (hb.Damage * (r.Percentage / 100f));
d = DamageObj(d);
ApplyHitToPhysicsSS(hb);
float s = hb.Stun - (hb.Stun * Mathf.Min(1f, (r.StunResist / 100f)));
if (hb.Stun > 0f && m_fighter)
{
if (s <= 0f)
{
return(HitResult.BLOCKED);
}
m_fighter.RegisterStun(s, true, hb);
}
if (Health <= 0f)
{
Killer = hb.Creator;
}
if (d == 0f)
{
return(HitResult.NONE);
}
else if (d < 0f)
{
return(HitResult.HIT);
}
else
{
return(HitResult.HEAL);
}
}
public void AddResistence(Resistence r)
{
Resistence fr = m_fullResistences[r.Element];
float pDiff = r.Percentage;
if (r.AvoidOverflow)
{
pDiff = Mathf.Min(100f - fr.Percentage, r.Percentage);
r.OverflowAmount = Mathf.Max(0f, r.Percentage - (100f - fr.Percentage));
}
fr.Percentage += pDiff;
fr.StunResist += r.StunResist;
fr.KnockbackResist += r.KnockbackResist;
if (!Resistences.Contains(r))
{
Resistences.Add(r);
}
}
public void RemoveResistence(Resistence r)
{
if (!Resistences.Contains(r))
{
return;
}
Resistence fr = m_fullResistences[r.Element];
fr.Percentage -= r.Percentage;
fr.StunResist -= r.StunResist;
fr.KnockbackResist -= r.KnockbackResist;
Resistences.Remove(r);
foreach (Resistence or in Resistences)
{
if (or.Element == r.Element && r.AvoidOverflow)
{
float pDiff = Mathf.Min(100f - fr.Percentage, or.OverflowAmount);
or.OverflowAmount = Mathf.Max(0f, or.OverflowAmount - (100f - fr.Percentage));
fr.Percentage += pDiff;
}
}
}
public void HandleDamage(float damage, DamageType type, Vector3 impactForce = new Vector3())
{
if (delta <= 0)
{
delta = DamageRatio;
Resistence r = resistences.FirstOrDefault(rest => rest.type == type);
float rValue = r?.value ?? 0;
float finalDamage = damage * Mathf.Clamp(type.Multiplier, 0.1f, 99999) - (rValue + (cell?.CellSize() ?? 0) / 2f);
Life = (int)(Life - finalDamage);
rg.AddForce(impactForce);
DamageFxInstance.SetActive(true);
cell?.ThrowLifeEvent(Life);
if (Life <= 0)
{
Die();
}
}
}
private void ApplyHitToPhysics(HitInfo hi)
{
Resistence r = GetAverageResistences(hi.Element);
m_physics.FreezeInAir(hi.FreezeTime);
Vector3 kb = hi.Knockback - (hi.Knockback * Mathf.Min(1f, (r.KnockbackResist / 100f)));
if (!m_physics)
{
return;
}
if (hi.IsFixedKnockback)
{
if (kb.y != 0f && hi.ResetKnockback)
{
m_physics.CancelVerticalMomentum();
}
m_physics.AddToVelocity(kb);
return;
}
Vector3 hitVector = transform.position - hi.mHitbox.transform.position;
float angle = Mathf.Atan2(hitVector.y, hitVector.x); //*180.0f / Mathf.PI;
Vector2 force = new Vector2(Mathf.Cos(angle), Mathf.Sin(angle));
force.Scale(new Vector2(kb.magnitude, kb.magnitude));
float counterF = m_physics.m_trueVelocity.y * (1 / ScaledTime.deltaTime);
if (counterF < 0)
{
force.y = force.y - counterF;
}
m_physics.AddToVelocity(force);
hi.Knockback = force;
}
public override void OnAddProperty()
{
bioVulnerability = GetComponent <Attackable>().AddResistence(ElementType.BIOLOGICAL, -100.0f, false, false, 0.0f, 70.0f, 70.0f);
}
public override void OnAddProperty()
{
fireResist = GetComponent <Attackable>().AddResistence(ElementType.FIRE, 25.0f);
lightningWeakness = GetComponent <Attackable>().AddResistence(ElementType.LIGHTNING, -25.0f);
fx = GetComponent <PropertyHolder> ().AddBodyEffect(FXBody.Instance.FXWet);
}
