using System;
using System.Collections.Generic;
using UnityEngine;

[RequireComponent(typeof(e2dTerrain))]
public class e2dTerrainGenerator : MonoBehaviour
{
	private class HeightComparer : IComparer<KeyValuePair<float, int>>
	{
		public int Compare(KeyValuePair<float, int> x, KeyValuePair<float, int> y)
		{
			return (x.Key < y.Key) ? (-1) : ((x.Key > y.Key) ? 1 : 0);
		}
	}

	public bool FullRebuild = e2dConstants.INIT_FULL_REBUILD;

	public float NodeStepSize = e2dConstants.INIT_NODE_STEP_SIZE;

	public Vector2 TargetPosition = e2dConstants.INIT_TARGET_POSITION;

	public Vector2 TargetSize = e2dConstants.INIT_TARGET_SIZE;

	public float TargetAngle = e2dConstants.INIT_TARGET_ANGLE;

	public e2dCurvePerlinPreset Perlin = (e2dCurvePerlinPreset)e2dPresets.GetDefault(e2dGeneratorCurveMethod.PERLIN);

	public e2dCurveVoronoiPreset Voronoi = (e2dCurveVoronoiPreset)e2dPresets.GetDefault(e2dGeneratorCurveMethod.VORONOI);

	public e2dCurveMidpointPreset Midpoint = (e2dCurveMidpointPreset)e2dPresets.GetDefault(e2dGeneratorCurveMethod.MIDPOINT);

	public e2dCurveWalkPreset Walk = (e2dCurveWalkPreset)e2dPresets.GetDefault(e2dGeneratorCurveMethod.WALK);

	public List<e2dGeneratorPeak> Peaks = new List<e2dGeneratorPeak>();

	public float[] CurveBlendingWeights = new float[4];

	public int SmoothIterations;

	public int CliffTextureIndex;

	public float CliffStartAngle;

	public List<float> TextureHeights;

	private e2dTerrain mTerrain;

	[NonSerialized]
	public UnityEngine.Object EditorReference;

	public e2dTerrain Terrain
	{
		get
		{
			if (mTerrain == null)
			{
				mTerrain = GetComponent<e2dTerrain>();
			}
			if (mTerrain == null)
			{
				e2dUtils.Error("Can't find the terrain component.");
			}
			return mTerrain;
		}
	}

	public int NodeCount
	{
		get
		{
			return 1 + Mathf.RoundToInt(TargetSize.x / NodeStepSize);
		}
	}

	private void OnEnable()
	{
		EditorReference = null;
	}

	private void SetPointsToCurve(Vector2[] points, bool fullRebuild)
	{
		if (fullRebuild || Terrain.TerrainCurve.Count == 0)
		{
			Terrain.AddCurvePoints(points, 0, Terrain.TerrainCurve.Count - 1);
			return;
		}
		int[] curveIndicesInTargetArea = GetCurveIndicesInTargetArea();
		if (curveIndicesInTargetArea[0] == -2)
		{
			float sqrMagnitude = (Terrain.TerrainCurve[0].position - points[points.Length - 1]).sqrMagnitude;
			float sqrMagnitude2 = (Terrain.TerrainCurve[Terrain.TerrainCurve.Count - 1].position - points[0]).sqrMagnitude;
			if (sqrMagnitude < sqrMagnitude2)
			{
				curveIndicesInTargetArea[0] = 0;
				curveIndicesInTargetArea[1] = -1;
			}
			else
			{
				curveIndicesInTargetArea[0] = Terrain.TerrainCurve.Count;
				curveIndicesInTargetArea[1] = Terrain.TerrainCurve.Count - 1;
			}
		}
		Terrain.AddCurvePoints(points, curveIndicesInTargetArea[0], curveIndicesInTargetArea[1]);
	}

	private int[] GetCurveIndicesInTargetArea()
	{
		Vector2[] targetAreaBoundary = GetTargetAreaBoundary();
		int num = -2;
		for (int i = 1; i < Terrain.TerrainCurve.Count; i++)
		{
			if (e2dUtils.SegmentIntersectsPolygon(Terrain.TerrainCurve[i - 1].position, Terrain.TerrainCurve[i].position, targetAreaBoundary))
			{
				num = i;
				break;
			}
		}
		if (e2dUtils.PointInConvexPolygon(Terrain.TerrainCurve[0].position, targetAreaBoundary))
		{
			num = 0;
		}
		int num2 = -2;
		for (int num3 = Terrain.TerrainCurve.Count - 1; num3 >= 1; num3--)
		{
			if (e2dUtils.SegmentIntersectsPolygon(Terrain.TerrainCurve[num3 - 1].position, Terrain.TerrainCurve[num3].position, targetAreaBoundary))
			{
				num2 = num3 - 1;
				break;
			}
		}
		if (e2dUtils.PointInConvexPolygon(Terrain.TerrainCurve[Terrain.TerrainCurve.Count - 1].position, targetAreaBoundary))
		{
			num2 = Terrain.TerrainCurve.Count - 1;
		}
		return new int[2] { num, num2 };
	}

	public Rect GetTargetAreaBoundingBox()
	{
		Rect result = default(Rect);
		result.xMin = float.MaxValue;
		result.yMin = float.MaxValue;
		result.xMax = float.MinValue;
		result.yMax = float.MinValue;
		Vector2[] targetAreaBoundary = GetTargetAreaBoundary();
		for (int i = 0; i < targetAreaBoundary.Length; i++)
		{
			Vector2 vector = targetAreaBoundary[i];
			if (vector.x < result.xMin)
			{
				result.xMin = vector.x;
			}
			if (vector.y < result.yMin)
			{
				result.yMin = vector.y;
			}
			if (vector.x > result.xMax)
			{
				result.xMax = vector.x;
			}
			if (vector.y > result.yMax)
			{
				result.yMax = vector.y;
			}
		}
		return result;
	}

	public Vector2[] GetTargetAreaBoundary()
	{
		return new Vector2[4]
		{
			TransformPointFromTargetArea(new Vector3(-0.5f * TargetSize.x, -0.5f * TargetSize.y)),
			TransformPointFromTargetArea(new Vector3(-0.5f * TargetSize.x, 0.5f * TargetSize.y)),
			TransformPointFromTargetArea(new Vector3(0.5f * TargetSize.x, 0.5f * TargetSize.y)),
			TransformPointFromTargetArea(new Vector3(0.5f * TargetSize.x, -0.5f * TargetSize.y))
		};
	}

	public Rect GetTargetAreaLocalBox()
	{
		return new Rect(-0.5f * TargetSize.x, -0.5f * TargetSize.y, TargetSize.x, TargetSize.y);
	}

	public Vector3 TransformPointFromTargetArea(Vector3 point)
	{
		point = Quaternion.Euler(0f, 0f, TargetAngle) * point;
		point.x += TargetPosition.x;
		point.y += TargetPosition.y;
		return point;
	}

	public Vector3 TransformPointIntoTargetArea(Vector3 point)
	{
		point.x -= TargetPosition.x;
		point.y -= TargetPosition.y;
		point = Quaternion.Euler(0f, 0f, 0f - TargetAngle) * point;
		return point;
	}

	public void FixTargetArea()
	{
		TargetSize.x = Mathf.Max(TargetSize.x, float.Epsilon);
		TargetSize.y = Mathf.Max(TargetSize.y, float.Epsilon);
		Rect targetAreaLocalBox = GetTargetAreaLocalBox();
		for (int i = 0; i < Peaks.Count; i++)
		{
			Vector3 vector = Peaks[i].position;
			if (vector.x < targetAreaLocalBox.xMin)
			{
				vector.x = targetAreaLocalBox.xMin;
			}
			if (vector.y < targetAreaLocalBox.yMin)
			{
				vector.y = targetAreaLocalBox.yMin;
			}
			if (vector.x > targetAreaLocalBox.xMax)
			{
				vector.x = targetAreaLocalBox.xMax;
			}
			if (vector.y > targetAreaLocalBox.yMax)
			{
				vector.y = targetAreaLocalBox.yMax;
			}
			Peaks[i].position = vector;
		}
	}

	public void GenerateCurve()
	{
		float[] debugHeightmap = null;
		GenerateCurve(ref debugHeightmap);
	}

	public void GenerateCurve(ref float[] debugHeightmap)
	{
		if (NodeCount < 2)
		{
			e2dUtils.Error("Map too small for generating.");
			return;
		}
		float num = 0f;
		float[] curveBlendingWeights = CurveBlendingWeights;
		foreach (float num2 in curveBlendingWeights)
		{
			num += num2;
		}
		float[] array = new float[NodeCount];
		float[] array2 = new float[NodeCount];
		for (int j = 0; j < NodeCount; j++)
		{
			array[j] = 0.5f;
		}
		bool flag = true;
		for (int k = 0; k < 4; k++)
		{
			if (num == 0f || CurveBlendingWeights[k] == 0f)
			{
				continue;
			}
			if (e2dUtils.DEBUG_FIXED_GENERATOR_SEED)
			{
				UnityEngine.Random.seed = 12345;
			}
			switch ((e2dGeneratorCurveMethod)k)
			{
			case e2dGeneratorCurveMethod.PERLIN:
			{
				bool flag2 = GenerateCurvePerlin(array2, GetTargetAreaLocalBox(), ref debugHeightmap);
				if (flag2)
				{
					NormalizeHeightmap(array2);
				}
				if (!flag2)
				{
					flag = false;
				}
				break;
			}
			case e2dGeneratorCurveMethod.VORONOI:
				if (!GenerateCurveVoronoi(array2, GetTargetAreaLocalBox(), ref debugHeightmap))
				{
					flag = false;
				}
				break;
			case e2dGeneratorCurveMethod.MIDPOINT:
			{
				bool flag2 = GenerateCurveMidpoint(array2, GetTargetAreaLocalBox(), ref debugHeightmap);
				if (flag2)
				{
					NormalizeHeightmap(array2);
				}
				if (!flag2)
				{
					flag = false;
				}
				break;
			}
			case e2dGeneratorCurveMethod.WALK:
			{
				bool flag2 = GenerateCurveWalk(array2, GetTargetAreaLocalBox(), ref debugHeightmap);
				if (flag2)
				{
					NormalizeHeightmap(array2);
				}
				if (!flag2)
				{
					flag = false;
				}
				break;
			}
			}
			for (int l = 0; l < array.Length; l++)
			{
				array[l] += (array2[l] - 0.5f) * CurveBlendingWeights[k] / num;
			}
		}
		if (flag)
		{
			NormalizeHeightmap(array);
		}
		Vector2[] targetAreaBoundary = GetTargetAreaBoundary();
		Vector2[] array3 = new Vector2[NodeCount];
		for (int m = 0; m < NodeCount; m++)
		{
			float num3 = (float)m / (float)(NodeCount - 1);
			array3[m] = (1f - num3) * targetAreaBoundary[0] + num3 * targetAreaBoundary[3];
			array3[m] += array[m] * (targetAreaBoundary[1] - targetAreaBoundary[0]);
		}
		SetPointsToCurve(array3, FullRebuild);
		Terrain.CurveClosed = false;
		Terrain.FixCurve();
		Terrain.FixBoundary();
		Terrain.RebuildAllMaterials();
		Terrain.RebuildAllMeshes();
	}

	private void NormalizeHeightmap(float[] heightMap)
	{
		float num = float.MaxValue;
		float num2 = float.MinValue;
		foreach (float num3 in heightMap)
		{
			if (num3 < num)
			{
				num = num3;
			}
			if (num3 > num2)
			{
				num2 = num3;
			}
		}
		if (!(num2 - num <= float.Epsilon))
		{
			for (int j = 0; j < heightMap.Length; j++)
			{
				heightMap[j] = (heightMap[j] - num) / (num2 - num);
			}
		}
	}

	private List<Vector2> PreparePeaks(int totalPeakCount, float peakRatio, bool includeCustomPeaks, Rect targetRect)
	{
		List<Vector2> list = new List<Vector2>();
		totalPeakCount = Mathf.Max(totalPeakCount, 2);
		bool flag = true;
		if (includeCustomPeaks)
		{
			foreach (e2dGeneratorPeak peak in Peaks)
			{
				float x = (peak.position.x - targetRect.xMin) / targetRect.width;
				float num = (peak.position.y - targetRect.yMin) / targetRect.height;
				list.Add(new Vector2(x, num));
				if (Mathf.Approximately(num, 1f))
				{
					flag = false;
				}
			}
		}
		while (list.Count < totalPeakCount)
		{
			float y = 0f;
			if (UnityEngine.Random.value <= peakRatio)
			{
				y = UnityEngine.Random.value;
			}
			list.Add(new Vector2(UnityEngine.Random.value, y));
		}
		if (flag)
		{
			float num2 = float.MinValue;
			int num3 = (includeCustomPeaks ? Peaks.Count : 0);
			for (int i = num3; i < list.Count; i++)
			{
				if (list[i].y > num2)
				{
					num2 = list[i].y;
				}
			}
			if (num2 > float.Epsilon)
			{
				for (int j = num3; j < list.Count; j++)
				{
					Vector2 value = list[j];
					value.y /= num2;
					list[j] = value;
				}
			}
		}
		return list;
	}

	private bool GenerateCurvePerlin(float[] heightMap, Rect targetRect, ref float[] debugHeightmap)
	{
		int a = 1 + Mathf.RoundToInt(Perlin.frequencyPerUnit * targetRect.width);
		a = Mathf.Max(a, 2);
		e2dPerlinNoise e2dPerlinNoise2 = new e2dPerlinNoise(Perlin.octaves, 1f, a, Perlin.persistence);
		e2dPerlinNoise2.Regenerate();
		for (int i = 0; i < heightMap.Length; i++)
		{
			float x = (float)i / (float)(heightMap.Length - 1);
			heightMap[i] = e2dPerlinNoise2.GetValue(x);
		}
		if (e2dUtils.DEBUG_GENERATOR_CURVE)
		{
			debugHeightmap = new float[10 * heightMap.Length];
			for (int j = 0; j < debugHeightmap.Length; j++)
			{
				float x2 = (float)j / (float)(debugHeightmap.Length - 1);
				debugHeightmap[j] = e2dPerlinNoise2.GetValue(x2) * targetRect.height;
			}
		}
		return true;
	}

	private bool GenerateCurveVoronoi(float[] heightMap, Rect targetRect, ref float[] debugHeightmap)
	{
		int totalPeakCount = Mathf.RoundToInt(Voronoi.frequencyPerUnit * targetRect.width);
		List<Vector2> peaks = PreparePeaks(totalPeakCount, Voronoi.peakRatio, Voronoi.usePeaks, targetRect);
		e2dVoronoi e2dVoronoi2 = new e2dVoronoi(peaks, Voronoi.peakType, Voronoi.peakWidth);
		for (int i = 0; i < heightMap.Length; i++)
		{
			float x = (float)i / (float)(heightMap.Length - 1);
			heightMap[i] = e2dVoronoi2.GetValue(x);
		}
		if (e2dUtils.DEBUG_GENERATOR_CURVE)
		{
			debugHeightmap = new float[10 * heightMap.Length];
			for (int j = 0; j < debugHeightmap.Length; j++)
			{
				float x2 = (float)j / (float)(debugHeightmap.Length - 1);
				debugHeightmap[j] = e2dVoronoi2.GetValue(x2) * targetRect.height;
			}
		}
		return !Voronoi.usePeaks;
	}

	private bool GenerateCurveMidpoint(float[] heightMap, Rect targetRect, ref float[] debugHeightmap)
	{
		List<Vector2> peaks = null;
		if (Midpoint.usePeaks)
		{
			peaks = PreparePeaks(Peaks.Count, 0f, true, targetRect);
		}
		int initialStep = Mathf.RoundToInt((float)heightMap.Length / (Midpoint.frequencyPerUnit * targetRect.width));
		e2dMidpoint e2dMidpoint2 = new e2dMidpoint(heightMap.Length, initialStep, Midpoint.roughness, peaks);
		e2dMidpoint2.Regenerate();
		for (int i = 0; i < heightMap.Length; i++)
		{
			heightMap[i] = e2dMidpoint2.GetValueAt(i);
			if (Midpoint.usePeaks)
			{
				heightMap[i] = Mathf.Clamp01(heightMap[i]);
			}
		}
		if (e2dUtils.DEBUG_GENERATOR_CURVE)
		{
			debugHeightmap = new float[heightMap.Length];
			for (int j = 0; j < heightMap.Length; j++)
			{
				debugHeightmap[j] = e2dMidpoint2.GetValueAt(j) * targetRect.height;
			}
		}
		return !Midpoint.usePeaks;
	}

	private bool GenerateCurveWalk(float[] heightMap, Rect targetRect, ref float[] debugHeightmap)
	{
		float num = 1f / (float)(heightMap.Length - 1);
		float num2 = targetRect.width / (float)(heightMap.Length - 1);
		float value = 1f / (Walk.frequencyPerUnit * targetRect.width);
		value = Mathf.Clamp01(value);
		float num3 = 0.5f;
		float num4 = 0f;
		float num5 = num3;
		float num6 = num3;
		heightMap[0] = num3;
		for (int i = 1; i < heightMap.Length; i++)
		{
			float num7 = (float)i / (float)(heightMap.Length - 1);
			float num8 = Mathf.Min(num7 % value, value - num7 % value);
			num8 = 1f - num8 * 2f / value;
			num8 = Mathf.Pow(num8, 10f);
			float num9 = num8 * Walk.angleChangePerUnit * num2 * (2f * UnityEngine.Random.value - 1f);
			num4 = Mathf.Repeat(num4 + num9 + 180f, 360f) - 180f;
			num4 = Mathf.Clamp(num4, -80f, 80f);
			float num10 = Mathf.Tan(num4 * ((float)Math.PI / 180f)) * num;
			num3 += num10;
			float num11 = (e2dConstants.WALK_COHESION_MAX - Walk.cohesionPerUnit) * (float)i * num * 0.5f;
			float num12 = Mathf.Clamp(num3, num6 - num11, num5 + num11);
			if (num3 != num12)
			{
				num4 = 0f;
			}
			num3 = num12;
			num5 = Mathf.Min(num5, num3);
			num6 = Mathf.Max(num6, num3);
			heightMap[i] = num3;
		}
		if (e2dUtils.DEBUG_GENERATOR_CURVE)
		{
			debugHeightmap = new float[heightMap.Length];
			for (int j = 0; j < heightMap.Length; j++)
			{
				debugHeightmap[j] = heightMap[j] * targetRect.height;
			}
		}
		return true;
	}

	public void SmoothCurve()
	{
		int[] curveIndicesInTargetArea = GetCurveIndicesInTargetArea();
		int num = curveIndicesInTargetArea[1] - curveIndicesInTargetArea[0] + 1;
		if (curveIndicesInTargetArea[0] == -2 || num < 2)
		{
			return;
		}
		float[] array = new float[num];
		float[] array2 = new float[num];
		for (int i = 0; i < num; i++)
		{
			array[i] = ((Vector2)TransformPointIntoTargetArea(Terrain.TerrainCurve[curveIndicesInTargetArea[0] + i].position)).y;
		}
		for (int j = 0; j < SmoothIterations; j++)
		{
			for (int k = 1; k < num - 1; k++)
			{
				float num2 = 0.5f * (array[k - 1] + array[k + 1]);
				num2 = 0.5f * (num2 + array[k]);
				array2[k] = num2;
			}
			for (int l = 1; l < num - 1; l++)
			{
				array[l] = array2[l];
			}
		}
		for (int m = 0; m < num; m++)
		{
			Vector2 vector = TransformPointIntoTargetArea(Terrain.TerrainCurve[curveIndicesInTargetArea[0] + m].position);
			vector.y = array[m];
			Terrain.TerrainCurve[curveIndicesInTargetArea[0] + m].position = TransformPointFromTargetArea(vector);
		}
		Terrain.FixCurve();
		Terrain.FixBoundary();
		Terrain.RebuildAllMaterials();
		Terrain.RebuildAllMeshes();
	}

	public void TextureTerrain()
	{
		if (TextureHeights.Count != Terrain.CurveTextures.Count)
		{
			e2dUtils.Error("TextureTerrain: TextureHeights and CurveTextures have different number of elements");
			return;
		}
		List<KeyValuePair<float, int>> list = new List<KeyValuePair<float, int>>();
		float num = float.MinValue;
		foreach (float textureHeight in TextureHeights)
		{
			float b = textureHeight;
			num = Mathf.Max(num, b);
		}
		if (num <= 0f)
		{
			e2dUtils.Error("TextureTerrain: no texture heights defined above ground");
			return;
		}
		for (int i = 0; i < TextureHeights.Count; i++)
		{
			if (TextureHeights[i] > 0f)
			{
				list.Add(new KeyValuePair<float, int>(TextureHeights[i] / num, i));
			}
		}
		list.Sort(new HeightComparer());
		int[] curveIndicesInTargetArea = GetCurveIndicesInTargetArea();
		int num2 = curveIndicesInTargetArea[1] - curveIndicesInTargetArea[0] + 1;
		if (curveIndicesInTargetArea[0] == -2 || num2 < 1)
		{
			return;
		}
		Rect targetAreaLocalBox = GetTargetAreaLocalBox();
		for (int j = 0; j < num2; j++)
		{
			Vector2 vector = TransformPointIntoTargetArea(Terrain.TerrainCurve[curveIndicesInTargetArea[0] + j].position);
			float num3 = (vector.y + 0.5f * targetAreaLocalBox.height) / targetAreaLocalBox.height;
			foreach (KeyValuePair<float, int> item in list)
			{
				if (num3 <= item.Key)
				{
					Terrain.TerrainCurve[curveIndicesInTargetArea[0] + j].texture = item.Value;
					break;
				}
			}
			if (j > 0 && j < num2 - 1)
			{
				Vector2 vector2 = TransformPointIntoTargetArea(Terrain.TerrainCurve[curveIndicesInTargetArea[0] + j - 1].position);
				Vector2 vector3 = TransformPointIntoTargetArea(Terrain.TerrainCurve[curveIndicesInTargetArea[0] + j + 1].position);
				float num4 = Mathf.Atan2(vector.y - vector2.y, vector.x - vector2.x) * 57.29578f;
				float num5 = Mathf.Atan2(vector3.y - vector.y, vector3.x - vector.x) * 57.29578f;
				if ((num4 >= CliffStartAngle && num5 >= CliffStartAngle) || (num4 <= 0f - CliffStartAngle && num5 <= 0f - CliffStartAngle))
				{
					Terrain.TerrainCurve[curveIndicesInTargetArea[0] + j].texture = CliffTextureIndex;
				}
			}
		}
		Terrain.RebuildAllMaterials();
		Terrain.RebuildAllMeshes();
	}
}