控制地图显示范围

 private void ControlDisplayArea(Vector3 pos, bool IsInit)
    {

        IntVector2 newcoord = GetCoord(pos);//新得到的地图下标
        if (IsInit)//如果为初始化显示
        {
            ControlDisplayAll(false);
            int x_min = newcoord.x - area >= 0 ? newcoord.x - area : 0;
            int y_min = newcoord.y - area >= 0 ? newcoord.y - area : 0;
            int x_max = newcoord.x + area <= size_x - 1 ? newcoord.x + area : size_x - 1;
            int y_max = newcoord.y + area <= size_z - 1 ? newcoord.y + area : size_z - 1;
            for (int i = y_min; i <= y_max; i++)
                for (int j = x_min; j <= x_max; j++)
                {
                    if (GetOrder(j, i) != -1)
                        map.GetChild(GetOrder(j, i)).gameObject.SetActive(true);
                }
            return;
        }
        if (newcoord == oldcoord)//如果对象下标未更新
            return;
        int index;//计算下标的辅助变量
        if (newcoord.x - oldcoord.x != 0)//左右方向更新
        {
            bool IsLeft = newcoord.x - oldcoord.x < 0 ? true : false;

            for (int i = newcoord.y - area; i <= newcoord.y + area; i++)//生成按新坐标边界
            {
                index = GetOrder(IsLeft ? newcoord.x - area : newcoord.x + area, i);
                if (index != -1)
                    map.GetChild(index).gameObject.SetActive(true);
            }
            for (int j = oldcoord.y - area; j <= oldcoord.y + area; j++)//消去按旧坐标边界
            {
                index = GetOrder(IsLeft ? oldcoord.x + area : oldcoord.x - area, j);
                if (index != -1)
                    map.GetChild(index).gameObject.SetActive(false);
            }
        }

        if (newcoord.y - oldcoord.y != 0)//上下方向更新
        {
            bool IsUp = newcoord.y - oldcoord.y > 0 ? true : false;

            for (int i = newcoord.x - area; i <= newcoord.x + area; i++)//生成按新坐标边界
            {
                index = GetOrder(i, IsUp ? newcoord.y + area : newcoord.y - area);
                if (index != -1)
                    map.GetChild(index).gameObject.SetActive(true);
            }
            for (int j = oldcoord.x - area; j <= oldcoord.x + area; j++)
            {
                index = GetOrder(j, IsUp ? oldcoord.y - area : oldcoord.y + area);
                if (index != -1)
                    map.GetChild(index).gameObject.SetActive(false);//消去按旧坐标边界
            }
        }
        oldcoord = newcoord;
    }

新的方法的原理。每次对象坐标改变时，先记录下改变前其n圈内的格子坐标，然后算出改变后n圈内的格子坐标，后者全部setActive(true).后者减去前者作为显示对象。前者减去后者作为隐藏对象

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

public class Control_Area : MonoBehaviour
{
    
    public Transform mPlayer;//监控对象
    public Transform mMap;//地图
    public int mMaxRow;//最大行数
    public int mMaxCol;//最大列数
    public int mSize;//chunk尺寸，用来计算目标所在坐标
    public int Area=3;//显示范围
    //坐标类

    private Coordinate CurCoord = new Coordinate(-99,-99);
    private List<Coordinate> curCbs = null;//用来显示范围内的格子
    private List<Coordinate> preCbs = null;//用来消去上次范围内但不在现范围内的格子


    /// <summary>
    /// 用来初始化参数
    /// </summary>
    /// <param name="max_row"></param>
    /// <param name="max_col"></param>
    /// <param name="size"></param>
    /// <param name="map"></param>
    /// <returns></returns>
    public void Init(int max_row, int max_col,int size,Transform map)
    {
        mMaxRow = max_row;
        mMaxCol = max_col;
        mSize = size;
        mMap = map;
    }

    public void Start()
    { 
        //初始化时隐藏所有chunk
        for (int i = 0; i < mMap.childCount; i++)
        {
            Transform tf = mMap.GetChild(i);
            tf.gameObject.SetActive(false);
        }
        InvokeRepeating("ChunkPositionUpdate", 0f, 1f);
    }

    /// <summary>
    /// 更新位置，允许超出范围
    /// </summary>
    /// <returns></returns>
    public void ChunkPositionUpdate()
    {
        if (mPlayer == null || mMap == null)
        {
            return;
        }
        //将人物的世界坐标变换为地图的局部坐标
        Vector3 localHeroPos = mMap.transform.InverseTransformPoint(mPlayer.transform.position);

        int col = (int)(localHeroPos.x / mSize);
        int row = (int)(localHeroPos.z / mSize);

       //如果仍然处于旧位置
        if (CurCoord.Row == row && CurCoord.Col == col)
        {
            return;
        }
        //先把旧的周围所有圈方块记录下来
        preCbs = null;
        curCbs = null;
        preCbs = new List<Coordinate>();
        curCbs = new List<Coordinate>();
        for (int i = 0; i <Area; ++i)
        {
            preCbs.AddRange(new List<Coordinate>(GetCoordInR(CurCoord.Row, CurCoord.Col, i)));
        }

        CurCoord.Row = row;
        CurCoord.Col = col;
        ChunkVisibleUpdate();
    }

    /// <summary>
    /// 获取ChunkID
    /// </summary>
    /// <param name="row"></param>
    /// <param name="col"></param>
    /// <returns>int</returns>
    public int GetChunkID(int row,int col)
    {
        return row * mMaxCol + col;
    }

    /// <summary>
    /// 更新可见度
    /// </summary>
    /// <returns></returns>
    public void ChunkVisibleUpdate()
    {
        for (int i = 0; i < Area; ++i)
        {
            Coordinate[] cbs = GetCoordInR(CurCoord.Row, CurCoord.Col, i);
            curCbs.AddRange(new List<Coordinate>(cbs)); 
        }
        List<Coordinate> display = new List<Coordinate>(curCbs.ToArray());//显示的新格子
        List<Coordinate> hide = new List<Coordinate>(preCbs.ToArray());//消去的旧格子
        for (int i = curCbs.Count-1; i >=0; i--)
        {
            for (int j = preCbs.Count-1; j>=0;j--)
            {
                if (Coordinate.Equal(curCbs[i],preCbs[j]))
                {
                    display[i] = null;
                    hide[j] = null;
                }
            }
        }

        display.RemoveAll(item =>{ return item == null; });//消去为null的坐标，这里指新坐标和旧坐标公有的格子
        hide.RemoveAll(item => { return item == null; });

        for (int i = 0; i < display.Count; ++i)
        {
            mMap.GetChild(GetChunkID(display[i].Row, display[i].Col)).gameObject.SetActive(true);
        }

        for (int i = 0; i < hide.Count; ++i)
        {
            mMap.GetChild(GetChunkID(hide[i].Row, hide[i].Col)).gameObject.SetActive(false);
        }

    }


    /// <summary>
    /// 返回地图范围内的坐标
    /// </summary>
    /// <param name="i"></param>
    /// <param name="j"></param>
    /// <returns>Coordinate</returns>
    private Coordinate GetValidCoord(int i, int j)
    {
        if (i < 0 || i >= mMaxRow || j < 0 || j >= mMaxCol)
        {
            return null;
        }
        return new Coordinate(i,j);
    }



    /// <summary>
    /// 返回返回指定第几围的坐标，若是超出范围则被排除在外
    /// </summary>
    /// <param name="row"></param>
    /// <param name="col"></param>
    /// <param name="r"></param>
    /// <returns>Coordinate[]</returns>
    private Coordinate[] GetCoordInR(int row, int col, int r)
    {
        List<Coordinate> list = new List<Coordinate>();
        for (int i = 0; i < 2 * r + 1; ++i)
        {
            Coordinate cb = GetValidCoord(row - r, col - r + i);
            if (cb != null && !list.Contains(cb))
            {
                list.Add(cb);
            }
            cb = GetValidCoord(row - r + i, col - r);
            if (cb != null && !list.Contains(cb))
            {
                list.Add(cb);
            }
            cb = GetValidCoord(row + r, col - r + i);
            if (cb != null && !list.Contains(cb))
            {
                list.Add(cb);
            }
            cb = GetValidCoord(row - r + i, col + r);
            if (cb != null && !list.Contains(cb))
            {
                list.Add(cb);
            }
        }
        return list.ToArray();
    }

    /// <summary>
    /// 坐标类
    /// </summary>
    class Coordinate
    {
        public int Row;
        public int Col;
        public Coordinate(int row, int col)
        {
            Row = row;
            Col = col;
        }
        public Coordinate(Coordinate m)
        {
            Row = m.Row;
            Col = m.Col;
        }
        public static bool Equal(Coordinate a, Coordinate b)
        {
            if (a.Col == b.Col && a.Row == b.Row)
                return true;
            else
                return false;
        }
    }
}