using System.Collections.Generic;
using System.IO;

using TGS;
using Unity.Mathematics;
using UnityEngine;
using NLDPB;


using System.Diagnostics;
using Gameplay;


public class MapHex
{
    public const float Length = 1.73205f;
    public const float Radius = 1.5f;

    public int index;
    public int Nx;
    public int Nz;

    public int Ax;
    public int Ay;
    public int Az;

    public float Wx;
    public float Wz;

    public int CityID;

	public int StaticCamp;

	public int Camp;

	public bool isChecked;

    public void SetData( int nWidth, int nHeight, int nIndex )
    {
        //index = Nz * nWidth + Nx
        index = nIndex;

        Nz = nIndex/nWidth;
        Nx = nIndex - Nz *nWidth;

        Az = Nz;
        Ax = Nx-Nz/2;
        Ay = -Ax-Az;

        Wx = (Nx + Nz * 0.5f - Nz / 2 ) * (Radius*2.0f);
        Wz = Nz * (Length*1.5f);
    }

    public override string ToString() {
        return $"index={index}, NC=({Nx}, {Nz}), AC=({Ax}, {Ay}, {Az}), WC=({Wx}, 0, {Wz}), City ID={CityID}";
    }

    public bool IsMyNext(MapHex hex)
    {
        int xOffset = math.abs(hex.Ax- Ax);
        int zOffset = math.abs(hex.Az-Az);
        int yOffset = math.abs(hex.Ay-Ay);
        
        return xOffset <= 1 && zOffset <= 1 && yOffset <= 1;
    }

    public bool IsMe(MapHex hex)
    {
        return hex.Nx == Nx && hex.Nz == Nz;
    }

    public int Distance(MapHex hex)
    {
        int xOffset = math.abs(hex.Ax- Ax);
        int zOffset = math.abs(hex.Az-Az);
        int yOffset = math.abs(hex.Ay-Ay);

        return math.max(yOffset, math.max(xOffset, zOffset));
    }

    public bool CanPass(int startCityID, int endCityID)
    {
        if(CityID > 0) {
            return CityID == startCityID || CityID == endCityID;
        } else {
            return true;
        }
    }

	public bool IsCampSource() {
		return Camp == (int)BattlefieldActorCamp.CampAsource || Camp == (int)BattlefieldActorCamp.CampBsource;
	}

	public int GetRealCamp() {
		switch (Camp) {
		case (int)BattlefieldActorCamp.CampAsource:
			return (int)BattlefieldActorCamp.CampA;
		case (int)BattlefieldActorCamp.CampBsource:
			return (int)BattlefieldActorCamp.CampB;
		default:
			return Camp;
		}
	}

	public bool IsRealCamp() {
		switch(Camp) {
		case (int)BattlefieldActorCamp.CampAsource:
		case (int)BattlefieldActorCamp.CampBsource:
		case (int)BattlefieldActorCamp.CampA:
		case (int)BattlefieldActorCamp.CampB:
			return true;
		}

		return false;
	}
}

public class PathNode
{
    public MapHex hex;
    public HexDir dir;

    //public List<PathNode> childs;

    public PathNode parent;

    public CityRoad cr;

    public int crIndex;

    public bool goRight;

    public PathNode()
    {
        //childs = new List<PathNode>();
    }
}

public class CityRoad
{
	public MapHex center;

    public MapHex [] road;

	public int Cover;

    public void GetNextHex(MapHex hex, out MapHex left, out int leftIndex, out MapHex right, out int rightIndex)
    {
        int index = -1;
        for(int i = 0; i < road.Length; i ++)
        {
            if(road[i].IsMe(hex))
            {
                index = i;
                break;
            }
        }

        if(index == -1)
        {
            UnityEngine.Debug.LogError($"CityRoad GetNextHex not found index, hex={hex}");
            left = null;
            right = null;
            leftIndex = 0;
            rightIndex = 0;
            return;
        }

        leftIndex = index -1;
        if(leftIndex < 0)
            leftIndex = road.Length - 1;

        rightIndex = index +1;
        if(rightIndex >= road.Length)
            rightIndex = 0;

        left = road[leftIndex];
        right = road[rightIndex];

        //UnityEngine.Debug.Log($"GetNextHex 1 rsult, index={index}, leftIndex={leftIndex}, rightIndex={rightIndex}");
        //UnityEngine.Debug.Log($"hex={hex}");
        //UnityEngine.Debug.Log($"left={left}");
        //UnityEngine.Debug.Log($"right={right}");
    }

    public void GetNextHex(int index, bool goRight, out MapHex next, out int nextIndex)
    {
        if(goRight)
        {
            index ++;
            if(index >= road.Length)
                index = 0;
        }
        else
        {
            index --;
            if(index < 0)
                index = road.Length - 1;
        }

        nextIndex = index;
        next = road[index];

        //UnityEngine.Debug.Log($"GetNextHex 2 index={index}, goRight={goRight}, nextIndex={nextIndex}");
        //UnityEngine.Debug.Log($"next={next}");
    }
}

public enum HexDir
{
    None = 0,
    RightUp,
    RightDown,
    LeftUp,
    LeftDown,
    Right,
    Left,
    UpRL,
    DownRL,
}

public class MapArea {
	public bool hasSource;
	public List<MapHex> hexes;

	public MapArea()
	{
		hexes = new List<MapHex>();
	}

	public void Reverse() {
		for (int i = 0; i < hexes.Count; i ++) {
			var h = hexes[i];
			if (h.Camp == (int)BattlefieldActorCamp.CampA) {
				h.Camp = (int)BattlefieldActorCamp.CampB;
			} else if (h.Camp == (int)BattlefieldActorCamp.CampB) {
				h.Camp = (int)BattlefieldActorCamp.CampA;
			}
		}
	}
}

public class MapGo {
	public int Camp;
	public GameObject go;
}

public class MapActor {
	public MapPathfind m_mp;

	public MapHex m_Current;
	public int m_Camp;
	public float m_Speed;

	bool IsMoving;

	GameObject go;

	List<MapHex> m_path;
	int pathIndex;

	public void Init(MapPathfind m, MapHex hex, int camp, float speed) {
		m_mp = m;
		m_Current = hex;
		m_Camp = camp;
		m_Speed = speed;

		go = GameObject.CreatePrimitive(PrimitiveType.Capsule);
		go.transform.position = new Vector3(m_Current.Wx, 0, m_Current.Wz);
		go.transform.localScale = new Vector3(2, 1, 2);

		m_mp.SetRoundCamp(false, hex, m_Camp, 3);
	}

	public void SetMove() {
		m_path = m_mp.DoFind2(this);
		if(m_path != null) {
			pathIndex = m_path.Count-1;
			IsMoving = true;
		}
	}

	public void Update() {
		if(IsMoving) {
			var curPos = go.transform.position;
			var target = new Vector3(m_path[pathIndex].Wx, 0, m_path[pathIndex].Wz);
			var moveDis = m_Speed * Time.deltaTime;
			var disCheck = Vector3.Distance(curPos, target); 
			if(moveDis > disCheck) {
				
				var nextHex = m_path[pathIndex];
				UnityEngine.Debug.Log($"m_Current.CityID={m_Current.CityID}, next City id={nextHex.CityID}");
				if(m_Current.CityID > 0 && nextHex.CityID <= 0) {	// 离开城了
					UnityEngine.Debug.Log("离开城了，m_Current.CityID=" +m_Current.CityID);
					var cr = m_mp.GetCityRoad(m_Current.CityID);
					m_mp.SetRoundCamp(true, cr.center, (int)BattlefieldActorCamp.BacNone, cr.Cover);
				} else if (m_Current.CityID <= 0 && nextHex.CityID > 0)  {
					UnityEngine.Debug.Log("进入城了，m_Current.CityID=" +m_Current.CityID);
					var cr = m_mp.GetCityRoad(nextHex.CityID);
					m_mp.SetRoundCamp(true, cr.center, m_Camp, cr.Cover);
				}

				m_Current = nextHex;
				m_mp.SetRoundCamp(false, m_Current, m_Camp, 3);

				go.transform.position = target;
				pathIndex --;
				if(pathIndex < 0) {
					IsMoving = false;
				}
			} else {
				var dir = target - curPos;
				dir.Normalize();
				go.transform.position = curPos + dir * moveDis;
			}
		}
	}
}

public class MapPathfind : MonoBehaviour
{
    public TerrainGridSystem TGS;

    MapData m_mapData;

    public bool Reload;

    public MapHex [] m_hexes;
	public MapGo [] m_hexCamps;

    // width x轴
    // height z轴

    public int ANx;
    public int ANz;
	public bool AMove;

    public int BNx;
    public int BNz; 

	public bool BMove;

    public bool FindPath;

    MapHex m_Start;
    MapHex m_End;

    Dictionary<int, CityRoad> m_Roads;

    public GameObject PathGo;

    public GameObject RoundGo;

    public GameObject CityGo;

    public GameObject StartGo;
    public GameObject EndGo;

    PathNode m_EndNode;

    public HashSet<int> m_CloseList;

    public bool DestroyPath;

	List<MapHex> BornPosA;
	List<MapHex> BornPosB;

	public GameObject Blue;
	public GameObject BlueSource;
	public GameObject BlueBuilding;
	public GameObject Red;
	public GameObject RedSource;
	public GameObject RedBuilding;

	public Transform CampRoot;

	MapActor A;
	MapActor B;

    void Start()
    {
        Reload = true;
        // 19,3   0,15
    }

    void CreateMap()
    {
        m_Roads = new Dictionary<int, CityRoad>();

        string jsonPath = Application.dataPath + "/Editor/MapPath/MapData_MapsTest.json";
        string txt = File.ReadAllText(jsonPath);
        m_mapData = JsonUtility.FromJson<MapData>(txt);

        UnityEngine.Debug.Log($"width={m_mapData.Width}, height={m_mapData.Height}, data length={m_mapData.BlocksData.Count}");

        m_hexes = new MapHex[m_mapData.BlocksData.Count];
        for(int i = 0; i < m_mapData.BlocksData.Count; i ++)
        {
            MapHex hex = new MapHex();
            hex.SetData(m_mapData.Width, m_mapData.Height, i);
            m_hexes[i] = hex;
            //UnityEngine.Debug.Log(hex.ToString());
        }

       
        AddCity(1, 5, 4, 1, 3 );
        //AddCity(2, 12, 21, 1 );
        //AddCity(3, 4, 19, 1 );
        //AddCity(4, 16, 19, 1 );
        //AddCity(5, 14, 18, 1 );
        //AddCity(6, 12, 17, 1 );
        //AddCity(7, 4, 16, 1 );
        //AddCity(8, 2, 15, 1 );
        //AddCity(9, 14, 13, 1, 3 );
        //AddCity(10, 6, 12, 1 );
        //AddCity(11, 15, 11, 1 );
        //AddCity(12, 9, 10, 1 );
        //AddCity(13, 9, 6, 1, 2 );

        AddCity(14, 15, 6, 2, 4 );
        //AddCity(15, 16, 16, 2 );
        //AddCity(16, 3, 11, 2 );
        AddCity(17, 14, 24, 2, 4 );

        AddCity(18, 9, 15, 3, 5 );

		m_hexCamps = new MapGo[m_hexes.Length];
		for(int i = 0; i < m_hexes.Length; i ++) {
			m_hexCamps[i] = new MapGo();
		}

		BornPosA = new List<MapHex>
		{
			m_hexes[GetIndex(0, 0)],
			m_hexes[GetIndex(1, 0)],
			m_hexes[GetIndex(0, 1)]
		};



		BornPosB = new List<MapHex>
		{
			m_hexes[GetIndex(19, 29)],
			m_hexes[GetIndex(18, 29)],
			m_hexes[GetIndex(19, 28)]
		};
    }

    public void AddCity(int nCityID, int Nx, int Nz, int range, int cover )
    {
        MapHex center = m_hexes[GetIndex(Nx, Nz)];

        // 找最外一圈路径
        List<MapHex> RoundRoad = new List<MapHex>();

        // 获取建筑所在的格子
        int MaxX = center.Ax + range;
        int MinX = center.Ax - range;
        int MaxY = center.Ay + range;
        int MinY = center.Ay - range;
        int MaxZ = center.Az + range;
        int MinZ = center.Az - range;

        for(int x = MinX; x <= MaxX; x ++)
        {
            for(int y = MinY; y <= MaxY; y ++)
            {
                int z = -x-y;
                if(z >= MinZ && z <= MaxZ)
                {
                    MapHex hex = GetMapHex(x, y, z);
					

                    if(x == MinX || x == MaxX
                    || y == MinY || y == MaxY
                    || z == MinZ || z == MaxZ)
                    {
                        RoundRoad.Add(hex);
                    } 
                    else
                    {
                        hex.CityID = nCityID;
                        //UnityEngine.Debug.Log(hex.ToString());

                        var go = Instantiate(CityGo);
                        go.transform.SetParent(transform);
                        go.transform.position = new Vector3(hex.Wx, 0, hex.Wz);
                    }
                }
            }
        }

        int RoadNodeCount = RoundRoad.Count;

        List<MapHex> rounds = new List<MapHex>();
        MapHex next = RoundRoad[0];
        rounds.Add(next);
        RoundRoad.RemoveAt(0);

        while(RoundRoad.Count > 0)
        {
            MapHex nextHex = null;
            for(int i = 0; i < RoundRoad.Count; i ++)
            {
                if(next.IsMyNext(RoundRoad[i]))
                {
                    next = RoundRoad[i];
                    RoundRoad.RemoveAt(i);
                    rounds.Add(next);
                    nextHex = next;
                    break;
                }
            }

            if(nextHex == null)
            {
                UnityEngine.Debug.LogError("nextHex not found ...");
                break;
            }
        }

        for(int i = 0; i < rounds.Count; i ++)
        {
            UnityEngine.Debug.Log($"find next, city={nCityID}, count={rounds.Count}, current={rounds[i]}");
        }
        
        if(rounds.Count == RoadNodeCount)
        {
            CityRoad cr = new CityRoad();
			cr.center = center;
            cr.road = rounds.ToArray();
			cr.Cover = cover;
            m_Roads.Add(nCityID, cr);

        /*
            for(int i = 0; i < cr.road.Length; i ++)
            {
                var go = Instantiate(RoundGo);
                go.transform.SetParent(transform);
                go.transform.position = new Vector3(cr.road[i].Wx, 0, cr.road[i].Wz);
            }
            //*/
        }
        else
        {
            UnityEngine.Debug.LogError($"Road create error, city={nCityID}, rounds.Count:{rounds.Count} != RoadNodeCount:{RoadNodeCount}");
        }


        /*
        UnityEngine.Debug.Log("Road Start ========================= count=" +rounds.Count);
        for(int i = 0; i < rounds.Count; i ++)
        {
            UnityEngine.Debug.Log(rounds[i]);
        }
        UnityEngine.Debug.Log("Road End =========================");
         */
    }

    int GetIndex(int Nx, int Nz)
    {
        return Nz*m_mapData.Width+Nx;
    }

	void clearChecked() {
		for(int i = 0; i < m_hexes.Length; i ++) {
			m_hexes[i].isChecked = false;
		}
	}

    void Update()
    {
        if(Reload)
        {
            Reload = false;
            CreateMap();
			InitRange(BornPosA, BornPosB);
			A = new MapActor();
			A.Init(this, BornPosA[0], (int)BattlefieldActorCamp.CampA, 3.0f);

			B = new MapActor();
			B.Init(this, BornPosB[0], (int)BattlefieldActorCamp.CampB, 3.0f);

			
        }

        // if(FindPath)
        // {   
            
        //     Stopwatch stopwatch = new Stopwatch();
        //     stopwatch.Start();
        //     DoFind2();
        //     stopwatch.Stop();
        //     FindPath = false;

        //     UnityEngine.Debug.Log($"DoFind2 执行时间: {stopwatch.ElapsedMilliseconds} 毫秒");
        // }

        if(DestroyPath)
        {
            DestroyPath = false;
            //删除本节点下所有的GameObect
			while (transform.childCount > 0)
            {
                DestroyImmediate(transform.GetChild(0).gameObject);
            }
        }

		if(A != null) {
			if(AMove) {
				AMove = false;
				A.SetMove();
			}

			A.Update();
		}

		if(B != null) {
			if(BMove) {
				BMove = false;
				B.SetMove();
			}
			B.Update();
		}

		CheckRange(BornPosA[0]);
		
		for(int i = 0; i < m_hexes.Length; i ++) {
			if(m_hexCamps[i].Camp != m_hexes[i].Camp) {
				if(m_hexCamps[i].go != null) {
					GameObject.Destroy(m_hexCamps[i].go);
					m_hexCamps[i].go = null;
				}

				m_hexCamps[i].Camp = m_hexes[i].Camp;
				switch(m_hexCamps[i].Camp)
				{
				case (int)BattlefieldActorCamp.CampA:
					{
						m_hexCamps[i].go = GameObject.Instantiate(Blue);
					}
					break;

				case (int)BattlefieldActorCamp.CampAsource:
					{
						m_hexCamps[i].go = GameObject.Instantiate(BlueSource);
					}
					break;

				case (int)BattlefieldActorCamp.CampAbuilding:
					{
						m_hexCamps[i].go = GameObject.Instantiate(BlueBuilding);
					}
					break;

				case (int)BattlefieldActorCamp.CampB:
					{
						m_hexCamps[i].go = GameObject.Instantiate(Red);
					}
					break;

				case (int)BattlefieldActorCamp.CampBsource:
					{
						m_hexCamps[i].go = GameObject.Instantiate(RedSource);
					}
					break;

				case (int)BattlefieldActorCamp.CampBbuilding:
					{
						m_hexCamps[i].go = GameObject.Instantiate(RedBuilding);
					}
					break;
				}

				if(m_hexCamps[i].go != null) {
					m_hexCamps[i].go.transform.SetParent(CampRoot);
					m_hexCamps[i].go.transform.position = new Vector3(m_hexes[i].Wx, 0, m_hexes[i].Wz);
				}

			}
		}

		
    }

    HexDir GetTargetPositionDir(MapHex start, MapHex end)
    {
        var dir = GetLineDir(start, end);
        if(dir != HexDir.None)
            return dir;

        if(end.Az > start.Az)
        {
            if(end.Ax < start.Ax && end.Ay < start.Ay)
            {
                return HexDir.UpRL;
            } 
            else if(end.Ay > start.Ay)
            {
                return HexDir.LeftUp;
            }
            else
            {
                return HexDir.RightUp;
            }
        }
        else
        {
            if(end.Ax > start.Ax && end.Ay > start.Ay)
            {
                return HexDir.DownRL;
            }
            else if(end.Ax < start.Ax)
            {
                return HexDir.LeftDown;
            }
            else
            {
                return HexDir.RightDown;
            }
        }
    }

    HexDir GetLineDir(MapHex start, MapHex end)
    {
        if(start.Ax == end.Ax)
        {
            if(end.Az > start.Az)
            {
                return HexDir.RightUp;
            }
            else
            {
                return HexDir.LeftDown;
            }
        }
        else if( start.Az == end.Az)
        {
            if(end.Ax > start.Ax)
            {
                return HexDir.Right;
            }
            else
            {
                return HexDir.Left;
            }
        }
        else if( start.Ay == end.Ay)
        {
            if(end.Az > start.Az)
            {
                return HexDir.LeftUp;
            }
            else
            {
                return HexDir.RightDown;
            }
        }

        return HexDir.None;
    }

    void AddPathNode(PathNode node, PathNode parent)
    {
        node.parent = parent;
    }

    bool GetNextNode(PathNode currentNode, List<PathNode> openList, int startCityID, int endCityID)
    {
        var dir = currentNode.dir;

        var nextHex = GetNextHex(currentNode.hex, dir);
        if(nextHex != null)
        {
            // 下一格是建筑，那当前这一格，肯定就在路点上
            if(!nextHex.CanPass(startCityID, endCityID))
            {
                // 如果当前格没有路点信息，则找左右两个路点作为下一格
                if(currentNode.cr == null)
                {
                    m_Roads.TryGetValue(nextHex.CityID, out CityRoad cr);
                    if(cr == null)
                    {
                        UnityEngine.Debug.LogError("City road not found, city id=" + nextHex.CityID);
                        return false;
                    }

                    cr.GetNextHex(currentNode.hex, out MapHex left, out int leftIndex, out MapHex right, out int rightIndex);
                    if(!m_CloseList.TryGetValue(left.index, out int hexIndex))
                    {
                        PathNode nodeLeft = new PathNode();
                        nodeLeft.hex = left;
                        nodeLeft.dir = GetTargetPositionDir(left, m_End);
                        nodeLeft.cr = cr;
                        nodeLeft.crIndex = leftIndex;
                        nodeLeft.goRight = false;
                        //nodeLeft.parent = currentNode;
                        AddPathNode(nodeLeft, currentNode);
                        if(m_End.IsMe(left))
                        {
                            m_EndNode = nodeLeft;
                            return true;
                        }
                        openList.Add(nodeLeft);
                    }
                    
                    if(!m_CloseList.TryGetValue(right.index, out int hexIndex2))
                    {
                        PathNode nodeRight = new PathNode();
                        nodeRight.hex = right;
                        nodeRight.dir = GetTargetPositionDir(right, m_End);
                        nodeRight.cr = cr;
                        nodeRight.crIndex = rightIndex;
                        nodeRight.goRight = true;
                        //nodeRight.parent = currentNode;
                        AddPathNode(nodeRight, currentNode);
                        if(m_End.IsMe(right))
                        {
                            m_EndNode = nodeRight;
                            return true;
                        }
                        openList.Add(nodeRight);
                    }
                    
                }
                else    // 当前格本身就在路点上，则找下一格路点
                {
                    currentNode.cr.GetNextHex(currentNode.crIndex, currentNode.goRight, out MapHex next, out int nextIndex);
                    if(!m_CloseList.TryGetValue(next.index, out int hexIndex2))
                    {
                        PathNode nodeNext = new PathNode();
                        nodeNext.hex = next;
                        nodeNext.cr = currentNode.cr;
                        nodeNext.dir = GetTargetPositionDir(next, m_End);
                        nodeNext.goRight = currentNode.goRight;
                        nodeNext.crIndex = nextIndex;
                        //nodeNext.parent = currentNode;
                        AddPathNode(nodeNext, currentNode);
                        if(m_End.IsMe(next))
                        {
                            m_EndNode = nodeNext;
                            return true;
                        }
                        openList.Add(nodeNext);
                    }
                }
            }
            else
            {
                PathNode nextNode = new PathNode();
                nextNode.hex = nextHex;
                nextNode.dir = dir;
                var dirNext = GetLineDir(nextHex, m_End);
                if(dirNext != HexDir.None)
                {
                    nextNode.dir = dirNext;
                }

                nextNode.parent = currentNode;
                AddPathNode(nextNode, currentNode);
                if(m_End.IsMe(nextHex))
                {
                    m_EndNode = nextNode;
                    return true;
                }

                openList.Add(nextNode);
            }
        }

        return false;
    }

    public List<MapHex> DoFind2(MapActor actor)
    {
        m_EndNode = null;
        m_CloseList = new HashSet<int>();
        m_Start = actor.m_Current;
        var StartCityID = m_Start.CityID;

		if(actor.m_Camp == (int)BattlefieldActorCamp.CampA) {
			if(m_Start.Nx == ANx && m_Start.Nz == ANz) {
				return null;
			}

			m_End = m_hexes[GetIndex(ANx, ANz)];
		} else {
			if(m_Start.Nx == BNx && m_Start.Nz == BNz) {
				return null;
			}

			m_End = m_hexes[GetIndex(BNx, BNz)];
		}
		
        //
        var EndCityID = m_End.CityID;

        StartGo.transform.position = new Vector3(m_Start.Wx, 0, m_Start.Wz);
        EndGo.transform.position = new Vector3(m_End.Wx, 0, m_End.Wz);

        List<PathNode> openList = new List<PathNode>();

        PathNode path = new PathNode();
        path.hex = m_Start;
        path.dir = GetTargetPositionDir(m_Start, m_End);
        openList.Add(path);

        List<MapHex> hexList = new List<MapHex>();
        while(openList.Count > 0)
        {
            //UnityEngine.Debug.Log("START ============================================== openList.Count=" + openList.Count);
            List<PathNode> newOpenList = new List<PathNode>();
            for(int i = 0; i < openList.Count; i ++)
            {
                hexList.Clear();
                var node = openList[i];
                m_CloseList.Add(node.hex.index);

                //UnityEngine.Debug.Log($"node.dir={node.dir}, node={node.hex}");
                switch(node.dir)
                {
                case HexDir.DownRL:
                    {
                        node.dir = HexDir.LeftDown;
                        if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                        {
                            UnityEngine.Debug.Log("LeftDown go end");
                            goto End;
                        }
                        
                        node.dir = HexDir.RightDown;

                        if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                        {
                            UnityEngine.Debug.Log("RightDown go end");
                            goto End;
                        }
                    }
                    break;

                case HexDir.UpRL:
                    {
                        node.dir = HexDir.LeftUp;
                        if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                        {
                            UnityEngine.Debug.Log("LeftUp go end");
                            goto End;
                        }
                        
                        node.dir = HexDir.RightUp;
                        if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                        {
                            UnityEngine.Debug.Log("RightUp go end");
                            goto End;
                        }
                    }
                    break;

                //*
                case HexDir.LeftUp:
                    {
                        node.dir = HexDir.Left;
                        if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                        {
                            UnityEngine.Debug.Log("LeftUp HexDir.Left go end");
                            goto End;
                        }

                        node.dir = HexDir.LeftUp;
                        if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                        {
                            UnityEngine.Debug.Log("HexDir.LeftUp go end");
                            goto End;
                        }
                    }
                    break;

                case HexDir.LeftDown:
                    {
                            node.dir = HexDir.Left;
                            if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                            {
                                UnityEngine.Debug.Log("LeftDown HexDir.Left go end");
                                goto End;
                            }

                            node.dir = HexDir.LeftDown;
                            if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                            {
                                UnityEngine.Debug.Log("HexDir.LeftDown go end");
                                goto End;
                            }
                    }
                    break;

                case HexDir.RightUp:
                    {
                            node.dir = HexDir.Right;
                            if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                            {
                                UnityEngine.Debug.Log("RightUp HexDir.Right go end");
                                goto End;
                            }

                            node.dir = HexDir.RightUp;
                            if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                            {
                                UnityEngine.Debug.Log("HexDir.RightUp go end");
                                goto End;
                            }
                    }
                    break;

                case HexDir.RightDown:
                    {
                            node.dir = HexDir.Right;
                            if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                            {
                                UnityEngine.Debug.Log("RightDown HexDir.Right go end");
                                goto End;
                            }

                            node.dir = HexDir.RightDown;
                            if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                            {
                                UnityEngine.Debug.Log("HexDir.RightDown go end");
                                goto End;
                            }
                    }
                    break;
                    //*/

                default:
                    {
                        if(GetNextNode(node, newOpenList, StartCityID, EndCityID))
                        {
                            UnityEngine.Debug.Log("default go end");
                            goto End;
                        }
                    }
                    break;    
                }
                
            }

            openList.Clear();
            openList.AddRange(newOpenList);

            //UnityEngine.Debug.Log("NEXT ============================================== openList.Count=" + openList.Count);
        }

End:
/*
        PathNode pathNode2 = m_EndNode;
        while(pathNode2.parent != null)
        {
            PathNode check = pathNode2.parent;
            while(check.parent != null)
            {
                var dir = GetLineDir(pathNode2.hex, check.hex);
                if(dir != HexDir.None)
                {
                    List<MapHex> list = new List<MapHex>();
                    MapHex hex = pathNode2.hex;
                    while(true)
                    {
                        MapHex nextHex = GetNextHex(hex, dir);
                        if(nextHex.CityID <= 0)
                        {
                            if(nextHex.IsMe(check.hex))
                            {
                                break;
                            }

                            list.Add(nextHex);
                            hex = nextHex;
                        }
                        else
                        {
                            list.Clear();
                            break;
                        }
                    }

                    if(list.Count > 0)
                    {
                        PathNode newAdd = pathNode2;
                        while(list.Count > 0)
                        {
                            PathNode newNext = new PathNode();
                            newNext.hex = list[0];
                            newAdd.parent = newNext;
                            newAdd = newNext;

                            list.RemoveAt(0);
                        }
                        newAdd.parent = check;
                    }
                }

                check = check.parent;
            }

            pathNode2 = pathNode2.parent;
        }
        //*/

		List<MapHex> result = new List<MapHex>();
        int nCount = 0;
        PathNode pathNode = m_EndNode;
        while(pathNode.parent != null)
        {
            UnityEngine.Debug.Log(pathNode.hex);

			result.Add(pathNode.hex);
            //var go = Instantiate(PathGo);
            //go.transform.SetParent(transform);
            //go.transform.position = new Vector3(pathNode.hex.Wx, 0, pathNode.hex.Wz);
            nCount ++;

            pathNode = pathNode.parent;
        }

        UnityEngine.Debug.Log("all path node count="+ nCount);

		return result;
    }

    MapHex GetMapHex(int Ax, int Ay, int Az)
    {
        int Nz = Az;
        int Nx = Ax+Az/2;
        //UnityEngine.Debug.Log($"GetMapHex Ax={Ax}, Ay={Ay}, Az={Az}, Nx={Nx}, Nz={Nz}");

        if(Nx < 0 || Nx > m_mapData.Width-1)
        {
            //UnityEngine.Debug.LogError($"GetMapHex 1 not found Nx={Nx}, Nz={Nz}");
            return null;
        }
            

        if(Nz < 0 || Nz > m_mapData.Height-1)
        {
            //UnityEngine.Debug.LogError($"GetMapHex 2 not found Nx={Nx}, Nz={Nz}");
            return null;
        }
            

        int index = GetIndex(Nx, Nz);
        return m_hexes[index];
    }

	public CityRoad GetCityRoad(int cityID) {
		if(m_Roads.TryGetValue(cityID, out CityRoad v)) {
			return v;
		}

		return null;
	}

    /*
    
    
    
    
    
    
    */
    MapHex GetNextHex(MapHex hex, HexDir dir)
    {
        switch(dir)
        {
        case HexDir.RightUp:
            {
                //往右上走，Ax不变，Az+1
                int NextAx = hex.Ax;
                int NextAz = hex.Az+1;
                int NextAy = -NextAx-NextAz;
                return GetMapHex(NextAx, NextAy, NextAz);
            }

        case HexDir.RightDown:
            {
                // 往右下走，Ay不变，Az-1
                int NextAz = hex.Az-1;
                int NextAy = hex.Ay;
                int NextAx = -NextAz-NextAy;
                return GetMapHex(NextAx, NextAy, NextAz);
            }

        case HexDir.LeftUp:
            {
                //往左上走，Ay不变，Az+1
                int NextAy = hex.Ay;
                int NextAz = hex.Az+1;
                int NextAx = -NextAz-NextAy;
                return GetMapHex(NextAx, NextAy, NextAz);
            }

        case HexDir.LeftDown:
            {
                //往左下走，Ax不变，Az-1
                int NextAx = hex.Ax;
                int NextAz = hex.Az-1;
                int NextAy = -NextAx-NextAz;
                return GetMapHex(NextAx, NextAy, NextAz);
            }

        case HexDir.Right:
            {
                //往右走，Az不变，Ay-1
                int NextAz = hex.Az;
                int NextAy = hex.Ay-1;
                int NextAx = -NextAz-NextAy;
                return GetMapHex(NextAx, NextAy, NextAz);
            }

        case HexDir.Left:
            {
                //往左走，Az不变，Ay+1
                int NextAz = hex.Az;
                int NextAy = hex.Ay+1;
                int NextAx = -NextAz-NextAy;
                return GetMapHex(NextAx, NextAy, NextAz);
            }

        default:
            UnityEngine.Debug.LogError("GetNextHex invalid dir, dir=" + dir);
            return null;
        }
    }

	// 获取指定阵营的空格子
	List<MapHex> GetRoundEmptyHex(MapHex center) {
		List<MapHex> result = new List<MapHex>();

		int MaxX = center.Ax + 1;
		int MinX = center.Ax - 1;
		int MaxY = center.Ay + 1;
		int MinY = center.Ay - 1;
		int MaxZ = center.Az + 1;
		int MinZ = center.Az - 1;
;
		for (int x = MinX; x <= MaxX; x++) {
			for (int y = MinY; y <= MaxY; y++) {
				int z = -x - y;
				if (z >= MinZ && z <= MaxZ) {
					var hex = GetMapHex(x, y, z);
					if (hex != null && hex != center && hex.CityID == 0 && !hex.isChecked) {
						hex.isChecked = true;
						result.Add(hex);
					}
				}
			}
		}

		return result;
	}

	public void SetRoundCamp(bool isBuilding, MapHex center, int camp , int length ) {
		length--;

		int MaxX = center.Ax + length;
		int MinX = center.Ax - length;
		int MaxY = center.Ay + length;
		int MinY = center.Ay - length;
		int MaxZ = center.Az + length;
		int MinZ = center.Az - length;

		for (int x = MinX; x <= MaxX; x++ ) {
			for (int y = MinY; y <= MaxY; y++) {
				int z = -x - y;
				if (z >= MinZ && z <= MaxZ) {
					var hex = GetMapHex(x, y, z);
					if (hex != null) {
						if (isBuilding) {
							if(camp == (int)BattlefieldActorCamp.CampA) {
								hex.Camp = (int)BattlefieldActorCamp.CampAbuilding;
							} else if(camp == (int)BattlefieldActorCamp.CampB) {
								hex.Camp = (int)BattlefieldActorCamp.CampBbuilding;
							} else if (camp == (int)BattlefieldActorCamp.BacNone) {
								if(hex.CityID <= 0) {
									hex.Camp = hex.StaticCamp;
								} else {
									hex.Camp = camp;
								}
							} else {
								hex.Camp = camp;
							}
						} else {
							if (hex.CityID == 0 && hex.Camp < (int)BattlefieldActorCamp.CampMax) { // 如果不是设置建筑范围，则周围有建筑范围，不能更新
								hex.Camp = camp;
							}
						}
					}
				}
			}
		}
	}


	// 获取周围相同阵营，并且没有检查过的格子
	List<MapHex> GetRoundUnchecked(MapHex center) {
		List<MapHex> result = new List<MapHex>();

		int MaxX = center.Ax + 1;
		int MinX = center.Ax - 1;
		int MaxY = center.Ay + 1;
		int MinY = center.Ay - 1;
		int MaxZ = center.Az + 1;
		int MinZ = center.Az - 1;

		for (int x = MinX; x <= MaxX; x++) {
			for (int y = MinY; y <= MaxY; y++) {
				int z = -x - y;
				if (z >= MinZ && z <= MaxZ) {
					var hex = GetMapHex(x, y, z);
					if( hex != null && !hex.isChecked && hex.CityID == 0 && hex.GetRealCamp() == center.GetRealCamp() ){
						hex.isChecked = true;
						result.Add(hex);
					}
				}
			}
		}

		return result;
	}

	// 获取任意一个未检查过的格子
	MapHex GetNextUnchecked() {
		for(int i = 0; i < m_hexes.Length; i ++) {
			var h = m_hexes[i];
			if (!h.isChecked && h.CityID == 0 && h.IsRealCamp() ) {
				h.isChecked = true;
				return h;
			}
		}

		return null;
	}


	void CheckRange(MapHex start) {
		clearChecked();

		List<MapArea> areas = new List<MapArea>();

		var nextHex = start;
		while(nextHex != null)  {
			var area = new MapArea();
			areas.Add(area);

			int checkIndex = 0;
			List<MapHex> checkList = new List<MapHex>();
			checkList.Add(nextHex);
			while(checkIndex < checkList.Count)  {
				var current = checkList[checkIndex];
				current.isChecked = true;
				checkIndex++;
				area.hexes.Add(current);

				if (current.IsCampSource()) {
					area.hasSource = true;
				}

				var result = GetRoundUnchecked(current);
				if (result.Count > 0 ){
					checkList.AddRange(result);
				}
			}

			nextHex = GetNextUnchecked();
		}

		for (int i = 0; i < areas.Count; i ++) {
			if (!areas[i].hasSource ){
				areas[i].Reverse();
			}
		}
	}

	// 采用膨胀算法初始化势力范围
	void InitRange( List<MapHex> BornPosA, List<MapHex> BornPosB) {
		clearChecked();

		int checkIndexA = 0;
		List<MapHex> checkListA = new List<MapHex>();
		checkListA.AddRange(BornPosA);
		for (int i = 0; i < checkListA.Count; i ++) {
			checkListA[i].isChecked = true;
			checkListA[i].Camp = (int)BattlefieldActorCamp.CampAsource;
		}

		int checkIndexB = 0;
		List<MapHex> checkListB = new List<MapHex>();
		checkListB.AddRange(BornPosB);
		for (int i = 0; i < checkListB.Count; i ++) {
			checkListB[i].isChecked = true;
			checkListB[i].Camp = (int)BattlefieldActorCamp.CampBsource;
		}

		bool working = true;
		while(working) {
			working = false;
			if (checkIndexA < checkListA.Count) {
				var current = checkListA[checkIndexA];
				current.isChecked = true;

				if (current.Camp == (int)BattlefieldActorCamp.BacNone) {
					current.Camp = (int)BattlefieldActorCamp.CampA; // 设置格子所属势力
					current.StaticCamp = (int)BattlefieldActorCamp.CampA;
				}

				var result = GetRoundEmptyHex(current); // 只获取周围没有阵营的空格子
				if (result.Count > 0) {
					checkListA.AddRange(result);
				}

				checkIndexA++;
				if (checkIndexA < checkListA.Count) {
					working = true;
				}
			}

			if (checkIndexB < checkListB.Count) {
				var current = checkListB[checkIndexB];
				current.isChecked = true;

				if (current.Camp == (int)BattlefieldActorCamp.BacNone) {
					current.Camp = (int)BattlefieldActorCamp.CampB; // 设置格子所属势力
					current.StaticCamp = (int)BattlefieldActorCamp.CampB;
				}

				var result = GetRoundEmptyHex(current); // 只获取周围没有阵营的空格子
				if (result.Count > 0) {
					checkListB.AddRange(result);
				}

				checkIndexB++;
				if (checkIndexB < checkListB.Count) {
					working = true;
				}
			}
		}
	}
}