using UnityEngine;

[AddComponentMenu("Modifiers/Hit")]
public class MegaHitDeform : MegaModifier
{
	public float hitradius = 1f;

	public float Hardness = 0.5f;

	public float deformlimit = 0.1f;

	public float scaleforce = 1000f;

	public float maxForce = 1f;

	private Vector3[] offsets;

	private float msize;

	public override string ModName()
	{
		return "Hit Deform";
	}

	public override void Modify(MegaModifiers mc)
	{
		if (offsets != null)
		{
			for (int i = 0; i < sverts.Length; i++)
			{
				sverts[i] = verts[i] + offsets[i];
			}
		}
	}

	public void Deform(Vector3 point, Vector3 normal, float force)
	{
		force = Mathf.Min(maxForce, force);
		if (!(force > 0.01f))
		{
			return;
		}
		float num = force * (msize * (0.1f / Mathf.Max(0.1f, Hardness)));
		float num2 = deformlimit;
		float num3 = num2 * num2;
		Vector3 vector = base.transform.InverseTransformPoint(point);
		Vector3 vector2 = base.transform.InverseTransformDirection(normal);
		for (int i = 0; i < verts.Length; i++)
		{
			float sqrMagnitude = (verts[i] + offsets[i] - vector).sqrMagnitude;
			if (!(sqrMagnitude <= num))
			{
				continue;
			}
			Vector3 vector3 = vector2 * (1f - sqrMagnitude / num) * num;
			offsets[i] += vector3;
			if (deformlimit > 0f)
			{
				vector3 = offsets[i];
				sqrMagnitude = vector3.sqrMagnitude;
				if (sqrMagnitude > num3)
				{
					offsets[i] = vector3 * (num2 / vector3.magnitude);
				}
			}
		}
	}

	private void Deform(Collision collision)
	{
		float num = Mathf.Min(maxForce, collision.impactForceSum.sqrMagnitude / scaleforce);
		if (num > 0.01f)
		{
			ContactPoint[] contacts = collision.contacts;
			for (int i = 0; i < contacts.Length; i++)
			{
				Deform(contacts[i].point, contacts[i].normal, num);
			}
		}
	}

	public override bool ModLateUpdate(MegaModContext mc)
	{
		return Prepare(mc);
	}

	public override bool Prepare(MegaModContext mc)
	{
		if (offsets == null || offsets.Length != mc.mod.verts.Length)
		{
			offsets = new Vector3[mc.mod.verts.Length];
		}
		msize = MegaUtils.SmallestValue(mc.bbox.Size());
		return true;
	}

	public void Repair(float repair)
	{
		Repair(repair, Vector3.zero, 0f);
	}

	public void Repair(float repair, Vector3 point, float radius)
	{
		point = base.transform.InverseTransformPoint(point);
		float num = radius * radius;
		for (int i = 0; i < offsets.Length && (!(radius > 0f) || !((point - verts[i]).sqrMagnitude >= num)); i++)
		{
			offsets[i] *= repair;
		}
	}

	public void OnCollisionEnter(Collision collision)
	{
		Deform(collision);
	}

	public void OnCollisionStay(Collision collision)
	{
		Deform(collision);
	}
}