using System.Collections.Generic;
using UnityEngine;

namespace Artngame.SKYMASTER
{
	public class ChainLightning_SKYMASTER : MonoBehaviour
	{
		public Transform target;

		private GameObject[] target1;

		public int zigs = 100;

		public float speed = 1f;

		public float scale = 1f;

		public Light startLight;

		public Light endLight;

		private PerlinSKYMASTER noise;

		public bool Energized;

		public bool is_parent;

		public int current_depth;

		public int max_depth;

		private int current_target_count;

		public int max_target_count = 3;

		private Transform this_transform;

		public bool Random_target;

		public float Affect_dist = 10f;

		private float Time_count;

		public float Change_target_delay = 0.5f;

		public bool Random_delay;

		public float Delay_offset = 1f;

		private float Target_delay;

		public bool Moving_Source;

		public float Particle_energy = 1f;

		public int optimize_factor = 5;

		public float ParticleSize = 5f;

		public bool Branches = true;

		public Vector3 Branch_Offset;

		public Vector3 offset_bias;

		private Vector3 Target_pos;

		private Vector3 Saved_start_pos;

		public float Downward_speed = 4f;

		public float Stop_dist = 1f;

		private bool cast_branches;

		public Color Branch_color = Color.white;

		[Range(1f, 6f)]
		public float Zigs_branching_divider = 2f;

		public bool offset_noise;

		public bool reset_noise;

		public bool Slow_on_end;

		public float Slow_down_height = 20f;

		public float Slow_divider = 40f;

		public Vector2 Light_delay = new Vector2(0f, 0.3f);

		private bool particle_on = true;

		public bool line_on;

		private LineRenderer Liner;

		private float stop_time;

		public Vector2 Line_delay = new Vector2(0.1f, 0.4f);

		public int Vertex_count = 30;

		public float Deviation = 10.2f;

		public Vector2 Line_width = new Vector2(10f, 10f);

		public float min_y_disp = 10f;

		public bool line_glow_on;

		private LineRenderer LinerGlow;

		public Color Glow_color = Color.blue;

		public Material Line_Lightning_mat;

		public List<LineRenderer> LineBranches = new List<LineRenderer>();

		public List<LineRenderer> LineBranchesGlow = new List<LineRenderer>();

		public int max_branches = 10;

		public bool SmoothLights;

		public float max_end_light_intensity = 1f;

		public float max_start_light_intensity = 8f;

		public float LightFadeSpeed = 5f;

		public float LightSpeed = 100f;

		public float LightRipple = 3f;

		public bool updateOnPositionchange;

		public Vector3 prev_pos;

		public int randomizeFactor = 30;

		public bool alignEndToStartLight;

		private void Start()
		{
			if (zigs == 0)
			{
				zigs = 1;
			}
			target1 = GameObject.FindGameObjectsWithTag("Conductor");
			if ((bool)endLight)
			{
				endLight.enabled = false;
				endLight.gameObject.SetActive(value: false);
			}
			if ((bool)startLight)
			{
				startLight.enabled = false;
				startLight.gameObject.SetActive(value: false);
			}
			Target_pos = base.transform.position;
			Saved_start_pos = Target_pos;
			this_transform = base.transform;
			Target_delay = Change_target_delay;
			if (Random_delay)
			{
				Target_delay = Random.Range(Change_target_delay - Delay_offset, Change_target_delay + Delay_offset);
			}
		}

		private void Update()
		{
			if (((target == null) & (Random.Range(0, 2) == 1)) || (updateOnPositionchange && prev_pos == this_transform.position && Random.Range(0, randomizeFactor) != 1))
			{
				return;
			}
			prev_pos = this_transform.position;
			if (line_on)
			{
				if (Liner == null)
				{
					Liner = GetComponent<LineRenderer>();
					if (Liner == null)
					{
						base.gameObject.AddComponent<LineRenderer>();
						Liner = GetComponent<LineRenderer>();
						Liner.startWidth = 20f;
						Liner.endWidth = 10f;
						Liner.startColor = Color.white;
						Liner.endColor = Color.white;
						Liner.material = Line_Lightning_mat;
					}
				}
				if (line_glow_on && LinerGlow == null)
				{
					GameObject gameObject = new GameObject();
					gameObject.name = "GlowHolder";
					gameObject.transform.parent = base.transform;
					gameObject.transform.localPosition = Vector3.zero;
					LinerGlow = gameObject.AddComponent<LineRenderer>();
					LinerGlow.startWidth = 17f;
					LinerGlow.endWidth = 30f;
					LinerGlow.startColor = Color.black;
					LinerGlow.endColor = Glow_color;
					LinerGlow.material = Line_Lightning_mat;
				}
				if (Branches)
				{
					if (LineBranches.Count < max_branches)
					{
						for (int i = 0; i < max_branches; i++)
						{
							GameObject obj = new GameObject();
							obj.name = "Lineholder" + i;
							obj.transform.parent = base.transform;
							obj.transform.localPosition = Vector3.zero;
							LineRenderer lineRenderer = obj.AddComponent<LineRenderer>();
							lineRenderer.startWidth = 5f;
							lineRenderer.endWidth = 10f;
							lineRenderer.startColor = Color.white;
							lineRenderer.endColor = Color.white;
							lineRenderer.material = Line_Lightning_mat;
							LineBranches.Add(lineRenderer);
						}
					}
					if (line_glow_on && LineBranchesGlow.Count < max_branches)
					{
						for (int j = 0; j < max_branches; j++)
						{
							GameObject obj2 = new GameObject();
							obj2.name = "Glowholder" + j;
							obj2.transform.parent = base.transform;
							obj2.transform.localPosition = Vector3.zero;
							LineRenderer lineRenderer2 = obj2.AddComponent<LineRenderer>();
							lineRenderer2.startWidth = 9f;
							lineRenderer2.endWidth = 20f;
							lineRenderer2.startColor = Color.black;
							lineRenderer2.endColor = Glow_color;
							lineRenderer2.material = Line_Lightning_mat;
							LineBranchesGlow.Add(lineRenderer2);
						}
					}
				}
			}
			if (!particle_on)
			{
				return;
			}
			if (noise == null)
			{
				noise = new PerlinSKYMASTER();
			}
			if (!(is_parent | (!is_parent & Energized & (current_depth < max_depth))))
			{
				return;
			}
			target1 = GameObject.FindGameObjectsWithTag("Conductor");
			if (target1 == null || target1.Length == 0)
			{
				return;
			}
			int num = Random.Range(0, target1.Length);
			if (Random_target)
			{
				if (Time.fixedTime - Time_count > Target_delay)
				{
					if (Vector3.Distance(target1[num].transform.position, base.transform.position) < Affect_dist)
					{
						target = target1[num].transform;
						Saved_start_pos = this_transform.position;
					}
					Time_count = Time.fixedTime;
					if (!is_parent & Energized & (current_depth < max_depth) & (current_target_count > max_target_count))
					{
						Energized = false;
					}
					current_target_count++;
				}
				if (target != null && Vector3.Distance(target.position, base.transform.position) > Affect_dist)
				{
					target = null;
				}
			}
			else
			{
				target = null;
				int num2 = 0;
				GameObject[] array = target1;
				foreach (GameObject gameObject2 in array)
				{
					if (Vector3.Distance(gameObject2.transform.position, base.transform.position) < Affect_dist)
					{
						target = gameObject2.transform;
					}
					num2++;
				}
				if (!is_parent & Energized & (current_depth < max_depth) & (current_target_count > max_target_count))
				{
					Energized = false;
				}
				current_target_count++;
			}
			float num3 = Time.time * speed * 0.1365143f;
			if (target != null)
			{
				float num4 = Vector3.Distance(Target_pos, target.position);
				if (num4 < Vector3.Distance(base.transform.position, target.position) / 2f && Branches)
				{
					cast_branches = true;
				}
				if ((Target_pos == target.position) | (num4 < Stop_dist))
				{
					target = null;
					Target_pos = this_transform.position;
					cast_branches = false;
				}
			}
			if (target != null)
			{
				Vector3 vector = offset_bias;
				if (offset_noise)
				{
					if (reset_noise)
					{
						vector.x = offset_bias.x + Mathf.Clamp(0.1f * noise.Noise(num3 + offset_bias.x), -0.15f, 0.15f);
						vector.x = Mathf.Clamp(offset_bias.x, -10.25f, 10.25f);
					}
					else
					{
						vector.x = offset_bias.x + Mathf.Clamp(0.1f * noise.Noise(num3 + offset_bias.x), -0.15f, 0.15f);
						vector.x = Mathf.Clamp(offset_bias.x, -0.25f, 0.25f);
						offset_bias = vector;
					}
				}
				float num5 = Downward_speed;
				if (Slow_on_end && Vector3.Distance(Target_pos, target.position) < Stop_dist + Slow_down_height)
				{
					num5 = Downward_speed / Slow_divider;
				}
				if (Moving_Source)
				{
					Target_pos = Vector3.Lerp(this_transform.position, target.position, num5 * Time.deltaTime);
				}
				else
				{
					Target_pos += num5 * (target.position - Target_pos).normalized;
				}
				if (line_on && Liner != null)
				{
					if (LinerGlow != null)
					{
						LinerGlow.enabled = true;
					}
					Liner.enabled = true;
					if (Branches)
					{
						for (int l = 0; l < LineBranches.Count; l++)
						{
							LineBranches[l].enabled = true;
							if (line_glow_on)
							{
								LineBranchesGlow[l].enabled = true;
							}
						}
					}
					int num6 = 30;
					float num7 = 10.2f;
					if (line_glow_on)
					{
						LinerGlow.positionCount = num6;
						LinerGlow.startWidth = 17f;
						LinerGlow.endWidth = 11f;
						LinerGlow.startColor = Color.black;
						LinerGlow.endColor = Glow_color;
					}
					Liner.startWidth = Line_width.x;
					Liner.endWidth = Line_width.y;
					List<Vector3> list = new List<Vector3>();
					List<Vector3> list2 = new List<Vector3>();
					if (Branches)
					{
						Liner.positionCount = num6;
					}
					else
					{
						Liner.positionCount = num6;
					}
					Vector3 item = Saved_start_pos;
					Vector3 zero = Vector3.zero;
					Vector3 vector2 = (target.position - this_transform.position) / num6;
					Liner.SetPosition(0, this_transform.position);
					for (int m = 0; m < num6; m++)
					{
						zero.x = Random.Range(item.x - num7 + vector2.x, item.x + num7 + vector2.x);
						zero.y = item.y + vector2.y;
						zero.z = Random.Range(item.z - num7 + vector2.z, item.z + num7 + vector2.z);
						if (Mathf.Abs(zero.y - item.y) < min_y_disp)
						{
							zero.y -= min_y_disp;
						}
						Liner.SetPosition(m, zero);
						if (line_glow_on)
						{
							LinerGlow.SetPosition(m, zero);
						}
						item = zero;
						if (((m / 5 - Mathf.RoundToInt(m / 5) == 0) & (m > num6 / 3)) && list.Count < max_branches / 3)
						{
							list.Add(item);
						}
					}
					Liner.SetPosition(num6 - 1, new Vector3(zero.x, target.position.y, zero.z));
					if (Branches)
					{
						for (int n = 0; n < list.Count; n++)
						{
							Vector3 item2 = list[n];
							Vector3 zero2 = Vector3.zero;
							LineBranches[n].positionCount = num6;
							LineBranches[n].startWidth = 5f;
							LineBranches[n].endWidth = 1f;
							LineBranches[n].SetPosition(0, list[n]);
							if (line_glow_on)
							{
								LineBranchesGlow[n].positionCount = num6;
								LineBranchesGlow[n].startWidth = 10f;
								LineBranchesGlow[n].endWidth = 5f;
								LineBranchesGlow[n].SetPosition(0, list[n]);
							}
							for (int num8 = 0; num8 < num6; num8++)
							{
								zero2.x = Random.Range(item2.x - num7 * 1f + vector2.x, item2.x + num7 * 2f + vector2.x);
								zero2.y = item2.y + vector2.y / (float)Random.Range(1, 2);
								zero2.z = Random.Range(item2.z - num7 * 1f + vector2.z, item2.z + num7 * 2f + vector2.z);
								LineBranches[n].SetPosition(num8, zero2);
								if (line_glow_on)
								{
									LineBranchesGlow[n].SetPosition(num8, zero2);
								}
								item2 = zero2;
								if (((num8 / 15 - Mathf.RoundToInt(num8 / 15) == 0) & (num8 > num6 / 3)) && list2.Count < max_branches / 3)
								{
									list2.Add(item2);
								}
							}
						}
						int count = list.Count;
						for (int num9 = 0; num9 < list2.Count; num9++)
						{
							Vector3 vector3 = list2[num9];
							Vector3 zero3 = Vector3.zero;
							LineBranches[num9 + count].positionCount = num6;
							LineBranches[num9 + count].startWidth = 3f;
							LineBranches[num9 + count].endWidth = 1f;
							LineBranches[num9 + count].SetPosition(0, list2[num9]);
							LineBranches[num9 + count].startColor = Color.white;
							LineBranches[num9 + count].endColor = new Color(0f, 0f, 0f, 0f);
							if (line_glow_on)
							{
								LineBranchesGlow[num9 + count].positionCount = num6;
								LineBranchesGlow[num9 + count].startWidth = 6f;
								LineBranchesGlow[num9 + count].endWidth = 4f;
								LineBranchesGlow[num9 + count].SetPosition(0, list2[num9]);
								LineBranchesGlow[num9 + count].startColor = Glow_color;
								LineBranchesGlow[num9 + count].endColor = new Color(0f, 0f, 0f, 0f);
							}
							for (int num10 = 0; num10 < num6; num10++)
							{
								zero3.x = (float)Random.Range(11, 12) + Random.Range(vector3.x - num7 * 1f + vector2.x, vector3.x + num7 * 2f + vector2.x);
								zero3.y = vector3.y + vector2.y / (float)Random.Range(1, 2);
								zero3.z = Random.Range(vector3.z - num7 * 1f + vector2.z, vector3.z + num7 * 2f + vector2.z);
								LineBranches[num9 + count].SetPosition(num10, zero3);
								if (line_glow_on)
								{
									LineBranchesGlow[num9 + count].SetPosition(num10, zero3);
								}
								vector3 = zero3;
							}
						}
					}
				}
				stop_time = Time.fixedTime;
				_ = Branches;
				if (cast_branches)
				{
					if (Random.Range(0, 2) != 1)
					{
					}
				}
				else
				{
					_ = Branches;
				}
				ChainLightning_SKYMASTER chainLightning_SKYMASTER = target.gameObject.GetComponent(typeof(ChainLightning_SKYMASTER)) as ChainLightning_SKYMASTER;
				if (chainLightning_SKYMASTER == null)
				{
					chainLightning_SKYMASTER = target.gameObject.GetComponentInChildren(typeof(ChainLightning_SKYMASTER)) as ChainLightning_SKYMASTER;
				}
				if (chainLightning_SKYMASTER != null && !chainLightning_SKYMASTER.is_parent)
				{
					chainLightning_SKYMASTER.Energized = true;
					chainLightning_SKYMASTER.max_depth = max_depth;
					chainLightning_SKYMASTER.current_depth = current_depth + 1;
				}
				int num11 = 1;
				num11 = Random.Range(1, optimize_factor);
				if ((bool)endLight)
				{
					if ((num11 == 1) & (target != null))
					{
						if (!SmoothLights)
						{
							endLight.enabled = true;
							endLight.gameObject.SetActive(value: true);
							if (alignEndToStartLight)
							{
								endLight.transform.position = new Vector3(Saved_start_pos.x, target.transform.position.y, Saved_start_pos.z);
							}
							else
							{
								endLight.transform.position = target.transform.position;
							}
						}
						else
						{
							endLight.enabled = true;
							endLight.gameObject.SetActive(value: true);
							endLight.intensity = Mathf.Lerp(endLight.intensity, max_end_light_intensity, Time.deltaTime * LightSpeed);
							if (alignEndToStartLight)
							{
								endLight.transform.position = new Vector3(Saved_start_pos.x, target.transform.position.y, Saved_start_pos.z);
							}
							else
							{
								endLight.transform.position = target.transform.position;
							}
						}
					}
					else if (!SmoothLights)
					{
						endLight.enabled = false;
					}
					else
					{
						endLight.intensity = Mathf.Lerp(endLight.intensity, 0f, Time.deltaTime * LightFadeSpeed * Random.Range(1f, LightRipple));
					}
				}
				if ((bool)startLight)
				{
					if ((num11 == 1) & (target != null))
					{
						if (!SmoothLights)
						{
							startLight.enabled = true;
							startLight.gameObject.SetActive(value: true);
							startLight.transform.position = Saved_start_pos;
						}
						else
						{
							startLight.enabled = true;
							startLight.gameObject.SetActive(value: true);
							startLight.intensity = Mathf.Lerp(startLight.intensity, max_start_light_intensity, Time.deltaTime * LightSpeed);
							startLight.transform.position = Saved_start_pos;
						}
					}
					else if (!SmoothLights)
					{
						startLight.enabled = false;
					}
					else
					{
						startLight.intensity = Mathf.Lerp(startLight.intensity, 0f, Time.deltaTime * LightFadeSpeed * Random.Range(1f, LightRipple));
					}
				}
			}
			else if (line_on && Liner != null && Time.fixedTime - stop_time > Random.Range(Line_delay.x, Line_delay.y))
			{
				Liner.startWidth = 0f;
				Liner.endWidth = 0f;
				if (line_glow_on)
				{
					LinerGlow.startWidth = 0f;
					LinerGlow.endWidth = 0f;
					LinerGlow.enabled = false;
				}
				Liner.enabled = false;
				if (Branches)
				{
					for (int num12 = 0; num12 < LineBranches.Count; num12++)
					{
						LineBranches[num12].startWidth = 0f;
						LineBranches[num12].endWidth = 0f;
						if (line_glow_on)
						{
							LineBranchesGlow[num12].startWidth = 0f;
							LineBranchesGlow[num12].endWidth = 0f;
							LineBranchesGlow[num12].enabled = false;
						}
						LineBranches[num12].enabled = false;
					}
				}
			}
			if ((bool)startLight & (target == null) & (Time.fixedTime - stop_time > Random.Range(Light_delay.x, Light_delay.y)))
			{
				if (!SmoothLights)
				{
					startLight.enabled = false;
					startLight.gameObject.SetActive(value: false);
				}
				else
				{
					startLight.intensity = Mathf.Lerp(startLight.intensity, 0f, Time.deltaTime * LightFadeSpeed * Random.Range(1f, LightRipple));
				}
			}
			if ((bool)endLight & (target == null))
			{
				if (!SmoothLights)
				{
					endLight.enabled = false;
					endLight.gameObject.SetActive(value: false);
				}
				else
				{
					endLight.intensity = Mathf.Lerp(endLight.intensity, 0f, Time.deltaTime * LightFadeSpeed * Random.Range(1f, LightRipple));
				}
			}
		}
	}
}