游戏开发日志

我来为您逐行详细讲解这个 `ViewMgr.cs` 文件。这是一个Unity游戏中的视野管理系统，用于优化游戏性能。

文件结构概览

这个文件主要包含以下几个部分：

数据结构和接口定义
视野管理器 `ViewMgr` 类
工具类 `ViewTools`

让我逐行为您讲解：

1. 命名空间和引用

```1:7:Scripts/WeiLai/Mgr/ViewMgr.cs

using System.Collections.Generic;

using UnityEngine;

using WeiLai.Common;

using WeiLai.GameWorld.Camera;

using WeiLai.GameWorld;

using UnityEngine.Rendering;

```

这些是必要的引用：

`System.Collections.Generic` - 用于List和Dictionary
`UnityEngine` - Unity核心功能
`WeiLai.Common` - 项目通用功能
`WeiLai.GameWorld.Camera` - 相机管理
`WeiLai.GameWorld` - 游戏世界相关
`UnityEngine.Rendering` - 渲染相关

2. 数据结构定义

GridRangeInt 类

```9:25:Scripts/WeiLai/Mgr/ViewMgr.cs

public class GridRangeInt : IRecycle

{

public int minPosX;

public int minPosY;

public int maxPosX;

public int maxPosY;

public void Recycle()

{

}

public void Fetch()

{

minPosX = 0;

minPosY = 0;

maxPosX = 0;

maxPosY = 0;

}

```

这个类表示整数网格范围：

继承 `IRecycle` 接口，支持对象池回收
存储网格的最小和最大X、Y坐标
`Recycle()` - 回收对象（这里为空实现）
`Fetch()` - 从对象池获取时重置数据

GridRangeFloat 类

```27:43:Scripts/WeiLai/Mgr/ViewMgr.cs

public class GridRangeFloat : IRecycle

{

public float minPosX;

public float minPosY;

public float maxPosX;

public float maxPosY;

public void Recycle()

{

}

public void Fetch()

{

minPosX = 0;

minPosY = 0;

maxPosX = 0;

maxPosY = 0;

}

```

与 `GridRangeInt` 类似，但使用浮点数存储世界坐标范围。

SkinnerItem 类

```45:70:Scripts/WeiLai/Mgr/ViewMgr.cs

public class SkinnerItem : IRecycle

{

public IRecycleSkinner m_Skinner;

public GridRangeInt m_RangeInt;

public GridRangeFloat m_RangeFloat;

public void Recycle()

{

m_Skinner = null;

if (m_RangeInt != null)

{

m_RangeInt.Recycle();

m_RangeInt = null;

}

if (m_RangeFloat != null)

{

m_RangeFloat.Recycle();

m_RangeFloat = null;

}

public void Fetch()

{

m_Skinner = null;

m_RangeFloat = null;

m_RangeInt = null;

}

```

这个类包装了皮肤对象和其范围信息：

`m_Skinner` - 实现了 `IRecycleSkinner` 接口的对象
`m_RangeInt` - 整数网格范围
`m_RangeFloat` - 浮点数世界坐标范围
`Recycle()` - 回收时清理所有引用
`Fetch()` - 获取时重置所有引用

3. 接口定义

IRecycleSkinnerMoveable 接口

```72:85:Scripts/WeiLai/Mgr/ViewMgr.cs

public interface IRecycleSkinnerMoveable

{

/// <summary>

/// 进入摄像机视野

/// </summary>

public void InCameraView();

/// <summary>

/// 退出摄像机视野

/// </summary>

public void OutCameraView();

/// <summary>

/// 获取位置

/// </summary>

public Vector3 GetPosition();

}

```

可移动对象的接口：

`InCameraView()` - 进入视野时的回调
`OutCameraView()` - 退出视野时的回调
`GetPosition()` - 获取当前位置

IRecycleSkinner 接口

```87:97:Scripts/WeiLai/Mgr/ViewMgr.cs

public interface IRecycleSkinner

{

/// <summary>

/// 进入摄像机视野

/// </summary>

public void InCameraView();

/// <summary>

/// 退出摄像机视野

/// </summary>

public void OutCameraView();

}

```

静态对象的接口，比可移动对象少了位置获取方法。

4. ViewItem 类

```99:105:Scripts/WeiLai/Mgr/ViewMgr.cs

/// <summary>

/// 存放格子数据的，这个就不缓存了，整个游戏初始化以后一直保留

/// </summary>

public class ViewItem

{

public bool m_Visible;

public List<SkinnerItem> m_SkinnerList;

}

```

表示一个网格单元：

`m_Visible` - 是否在视野内
`m_SkinnerList` - 该网格内的所有皮肤对象列表

5. ViewMgr 主类

成员变量

```107:130:Scripts/WeiLai/Mgr/ViewMgr.cs

public class ViewMgr : Singleton<ViewMgr>

{

/// <summary>

/// 视野相机

/// </summary>

private Camera m_ViewCamera;

/// <summary>

/// 所有的视野对象

/// </summary>

private Dictionary<int, ViewItem> m_ItemMap = new Dictionary<int, ViewItem>();

/// <summary>

/// 上一次对象

/// </summary>

private List<ViewItem> m_LastViewItems = new List<ViewItem>();

/// <summary>

/// 怪物listcache

/// </summary>

private List<Monster> m_MonsterList = new List<Monster>();

private List<SceneGridItem> m_SceneGridList = new List<SceneGridItem>();

/// <summary>

/// 皮肤和对应皮肤管理对象的缓存容器

/// </summary>

private Dictionary<IRecycleSkinner, SkinnerItem>

m_CacheSkinner = new Dictionary<IRecycleSkinner, SkinnerItem>();

private List<IRecycleSkinnerMoveable> m_Moveables = new List<IRecycleSkinnerMoveable>();

```

`m_ViewCamera` - 视野相机引用
`m_ItemMap` - 所有网格的字典，key是网格ID
`m_LastViewItems` - 上一帧在视野内的网格列表
`m_MonsterList` - 视野内怪物的缓存列表
`m_SceneGridList` - 视野内场景网格的缓存列表
`m_CacheSkinner` - 皮肤对象到SkinnerItem的映射
`m_Moveables` - 可移动对象列表

初始化方法

```132:135:Scripts/WeiLai/Mgr/ViewMgr.cs

public void InitData()

{

m_ItemMap.Clear();

}

```

清空所有网格数据。

可移动对象管理

```137:147:Scripts/WeiLai/Mgr/ViewMgr.cs

public void AddMoveableItem(IRecycleSkinnerMoveable skinner)

{

return;

m_Moveables.Add(skinner);

}

public void RemoveMoveableItem(IRecycleSkinnerMoveable skinner)

{

return;

m_Moveables.Remove(skinner);

}

```

注意这里直接返回了，说明可移动对象功能被暂时禁用。

添加视野对象

```149:155:Scripts/WeiLai/Mgr/ViewMgr.cs

public void AddViewItem(IRecycleSkinner skinner, float posX, float posY)

{

return;

AddViewItem(skinner, ViewTools.GetGridRange(posX, posY), ViewTools.GetGridRangeFloat(posX, posY));

}

```

这个重载方法也被禁用了，原本应该调用下面的完整版本。

```157:200:Scripts/WeiLai/Mgr/ViewMgr.cs

public void AddViewItem(IRecycleSkinner skinner, GridRangeInt gridRange, GridRangeFloat gridRangeFloat)

{

return;

if (m_CacheSkinner.ContainsKey(skinner))

{

MyLogger.Error("why add again?");

return;

}

SkinnerItem skinnerItem = CacheObjectMgr.Inst.Fetch<SkinnerItem>();

skinnerItem.m_Skinner = skinner;

skinnerItem.m_RangeInt = gridRange;

skinnerItem.m_RangeFloat = gridRangeFloat;

m_CacheSkinner[skinner] = skinnerItem;

var minX = gridRange.minPosX;

var minY = gridRange.minPosY;

var maxX = gridRange.maxPosX;

var maxY = gridRange.maxPosY;

//如果对象占用的网格足够大，那就放多个格子上，检测的时候，只要有一个格子在视野内也就显示出来

for (int i = minX; i <= maxX; i++)

{

for (int j = minY; j <= maxY; j++)

{

var key = ViewTools.BlockPosToId(i, j);

#if UNITY_EDITOR

if (key < 0)

{

UnityEngine.Debug.LogError("key < 0");

}

#endif

if (!m_ItemMap.TryGetValue(key, out var item))

{

item = new ViewItem();

item.m_Visible = true;

item.m_SkinnerList = new List<SkinnerItem>();

m_ItemMap.Add(key, item);

}

item.m_SkinnerList.Add(skinnerItem);

}

```

这个方法也被禁用了，原本的逻辑是：

检查是否重复添加
从对象池获取SkinnerItem并设置数据
将对象添加到所有覆盖的网格中
如果网格不存在则创建新的

移除视野对象

```202:230:Scripts/WeiLai/Mgr/ViewMgr.cs

public void RemoveViewItem(IRecycleSkinner skinner)

{

return;

if (!m_CacheSkinner.TryGetValue(skinner, out var skinnerItem))

{

return;

}

m_CacheSkinner.Remove(skinner);

if (skinnerItem != null)

{

var minX = skinnerItem.m_RangeInt.minPosX;

var minY = skinnerItem.m_RangeInt.minPosY;

var maxX = skinnerItem.m_RangeInt.maxPosX;

var maxY = skinnerItem.m_RangeInt.maxPosY;

//如果对象占用的网格足够大，那就放多个格子上，检测的时候，只要有一个格子在视野内也就显示出来

for (int i = minX; i <= maxX; i++)

{

for (int j = minY; j <= maxY; j++)

{

var key = ViewTools.BlockPosToId(i, j);

if (m_ItemMap.TryGetValue(key, out var item))

{

skinnerItem.Recycle();

item.m_SkinnerList.Remove(skinnerItem);

}

else

{

MyLogger.Error("skinner not found");

}

```

这个方法也被禁用了，原本的逻辑是：

从缓存中获取SkinnerItem
从所有覆盖的网格中移除该对象
回收SkinnerItem

视野检查

```232:242:Scripts/WeiLai/Mgr/ViewMgr.cs

public void CheckSkinnerInView()

{

if (m_ItemMap.Count > 0)

{

//假设所有格子不可见

foreach (var viewItem in m_LastViewItems)

{

viewItem.m_Visible = false;

}

_CheckGridItemInView();

}

```

主要的视野检查方法：

先将所有上一帧可见的网格标记为不可见
调用内部方法进行详细检查

添加视野内项目

```244:252:Scripts/WeiLai/Mgr/ViewMgr.cs

private void _AddItemInView(ViewItem item)

{

//设置格子成可见

item.m_Visible = true;

if (!m_LastViewItems.Contains(item))

{

//保证，只添加一次

m_LastViewItems.Add(item);

}

```

将网格标记为可见并添加到当前视野列表。

检查可移动对象

```254:268:Scripts/WeiLai/Mgr/ViewMgr.cs

private void _CheckMoveableInView(float minX, float minY, float maxX, float maxY)

{

for (int i = 0; i < m_Moveables.Count; i++)

{

var skinner = m_Moveables[i];

var pos = skinner.GetPosition();

if (pos.x > minX && pos.x < maxX && pos.y > minY &&

pos.y < maxY)

{

skinner.InCameraView();

}

else

{

skinner.OutCameraView();

}

```

检查可移动对象是否在视野范围内：

遍历所有可移动对象
获取其位置
判断是否在视野范围内
调用相应的回调方法

核心视野检查逻辑

```270:320:Scripts/WeiLai/Mgr/ViewMgr.cs

private void _CheckGridItemInView()

{

var ctrl = CameraMgr.Inst.m_CameraMoveCtrl;

//扩大1个格子单位，以免出现刚进格子的时候，因加载延迟导致的对象闪烁的效果

int minX = Mathf.FloorToInt(ctrl.m_MinPosX / CameraMgr.m_ViewWidth) - 1;

int minY = Mathf.FloorToInt(ctrl.m_MinPosY / CameraMgr.m_ViewHeight) - 1;

int maxX = Mathf.CeilToInt(ctrl.m_MaxPosX / CameraMgr.m_ViewWidth) + 1;

int maxY = Mathf.CeilToInt(ctrl.m_MaxPosY / CameraMgr.m_ViewHeight) + 1;

_CheckMoveableInView(ctrl.m_MinPosX - 2, ctrl.m_MinPosY, ctrl.m_MaxPosX + 2, ctrl.m_MaxPosY);

//检查在视野内的范围内是否有格子数据，一般没数据就没有格子

for (int i = minX; i <= maxX; i++)

{

for (int j = minY; j <= maxY; j++)

{

var key = ViewTools.BlockPosToId(i, j);

if (m_ItemMap.TryGetValue(key, out var item))

{

_AddItemInView(item);

}

//更新格子内的对象视野

var minPosx = ctrl.m_MinPosX - 2;

var minPosy = ctrl.m_MinPosY - 2;

var maxPosx = ctrl.m_MaxPosX + 2;

var maxPosy = ctrl.m_MaxPosY + 2;

for (int i = m_LastViewItems.Count - 1; i >= 0; i--)

{

var item = m_LastViewItems[i];

if (item.m_Visible)

{

for (int j = item.m_SkinnerList.Count - 1; j >= 0; j--)

{

//格子部分在视野内，那么就会有的对象在视野范围内，有的对象不在视野范围内

var skinner = item.m_SkinnerList[j];

if (ViewTools.CheckCollision(skinner.m_RangeFloat.minPosX,

skinner.m_RangeFloat.minPosY,

skinner.m_RangeFloat.maxPosX,

skinner.m_RangeFloat.maxPosY

, minPosx, minPosy, maxPosx, maxPosy))

{

skinner.m_Skinner.InCameraView();

}

else

{

skinner.m_Skinner.OutCameraView();

}

else

{

//整个格子都不在视野内了，那么格子内的对象也都不在视野范围内

for (int j = item.m_SkinnerList.Count - 1; j >= 0; j--)

{

var skinner = item.m_SkinnerList[j];

skinner.m_Skinner.OutCameraView();

}

//不再视野内的移除掉，只保留在视野内的

m_LastViewItems.RemoveAt(i);

}

```

这是最核心的视野检查逻辑：

**计算视野范围**：

获取相机控制器的视野范围
扩大1个格子单位避免闪烁
转换为网格坐标

**检查可移动对象**：

调用可移动对象检查方法

**检查网格可见性**：

遍历视野范围内的所有网格
如果网格存在数据，标记为可见

**更新对象视野状态**：

遍历上一帧可见的网格
对每个网格内的对象进行碰撞检测
根据是否在视野内调用相应的回调
移除不再可见的网格

获取视野内对象

```322:340:Scripts/WeiLai/Mgr/ViewMgr.cs

public List<Monster> GetMonstersInView()

{

if (SceneMgr.Inst.m_CurScene.GetIsCheckView())

{

m_MonsterList.Clear();

for (int i = 0; i < m_LastViewItems.Count; i++)

{

var viewItem = m_LastViewItems[i];

for (int j = 0; j < viewItem.m_SkinnerList.Count; j++)

{

var skinnerItem = viewItem.m_SkinnerList[j];

if (skinnerItem.m_Skinner is Monster monster)

{

m_MonsterList.Add(monster);

}

//else

//{

//如果不做视野管理，就直接返回m_MonsterList，其怪物在AddViewItem的时候就添加进去且一直存在，直到RemoveViewItem才移除

//}

return m_MonsterList;

}

```

获取视野内的怪物列表：

检查当前场景是否启用视野检查
清空缓存列表
遍历所有可见网格
提取其中的Monster对象
返回列表

```342:356:Scripts/WeiLai/Mgr/ViewMgr.cs

/// <summary>

/// 获取视野内的格子

/// </summary>

/// <returns></returns>

public List<SceneGridItem> GetGridItemInView()

{

m_SceneGridList.Clear();

foreach (var viewItem in m_LastViewItems)

{

foreach (var skinnerItem in viewItem.m_SkinnerList)

{

if (skinnerItem.m_Skinner is SceneGridItem sceneGridItemData)

{

m_SceneGridList.Add(sceneGridItemData);

}

return m_SceneGridList;

}

```

获取视野内的场景网格列表，逻辑与获取怪物类似。

清理方法

```358:378:Scripts/WeiLai/Mgr/ViewMgr.cs

protected override void OnUnInit()

{

if(m_CacheSkinner.Count > 0)

{

//MyLogger.Error("why has item?");

}

foreach (var kvViewItem in m_CacheSkinner)

{

kvViewItem.Value.Recycle();

}

m_CacheSkinner.Clear();

m_LastViewItems.Clear();

m_ItemMap.Clear();

m_MonsterList.Clear();

base.OnUnInit();

}

```

清理所有数据：

回收所有SkinnerItem
清空所有集合
调用基类清理方法

6. ViewTools 工具类

静态变量

```382:384:Scripts/WeiLai/Mgr/ViewMgr.cs

public static class ViewTools

{

public static Vector2 m_GridSize = new(3.8f, 3.0f);

private static Vector2 m_HalfGridSize = m_GridSize / 2.0f;

```

定义网格大小和半网格大小。

网格坐标转换

```386:390:Scripts/WeiLai/Mgr/ViewMgr.cs

public static int BlockPosToId(int x, int y)

{

return (x + 1000) | ((y + 1000) << 16);

}

```

将网格坐标转换为唯一ID：

加1000是为了处理负数坐标
使用位运算将X和Y坐标组合成一个整数

```392:396:Scripts/WeiLai/Mgr/ViewMgr.cs

public static void IdToBlockPos(int id, out int x, out int y)

{

x = id & 0xFFFF - 1000;

y = (id >> 16) - 1000;

}

```

将ID转换回网格坐标：

使用位运算分离X和Y坐标
减去1000恢复原始坐标

获取网格大小

```398:402:Scripts/WeiLai/Mgr/ViewMgr.cs

public static Vector3 GetGridSize()

{

//配置的是每个100个像素等于1个unity单位

return m_GridSize;

}

```

返回网格大小，注释说明100像素=1Unity单位。

获取世界坐标范围

```408:418:Scripts/WeiLai/Mgr/ViewMgr.cs

/// <summary>

/// 获取世界坐标的范围

/// </summary>

/// <param name="x"></param>

/// <param name="y"></param>

/// <returns></returns>

public static GridRangeFloat GetGridRangeFloat(float x, float y)

{

var ret = CacheObjectMgr.Inst.Fetch<GridRangeFloat>();

ret.minPosX = x - m_HalfGridSize.x;

ret.minPosY = y - m_HalfGridSize.y;

ret.maxPosX = x + m_HalfGridSize.x;

ret.maxPosY = y + m_HalfGridSize.y;

return ret;

}

```

根据中心点计算世界坐标范围：

从对象池获取GridRangeFloat
计算以中心点为中心的矩形范围
返回范围对象

获取网格范围

```424:434:Scripts/WeiLai/Mgr/ViewMgr.cs

/// <summary>

/// 获取占据格子的范围

/// </summary>

/// <param name="x"></param>

/// <param name="y"></param>

/// <returns></returns>

public static GridRangeInt GetGridRange(float x, float y)

{

var ret = CacheObjectMgr.Inst.Fetch<GridRangeInt>();

ret.minPosX = Mathf.FloorToInt((x - m_HalfGridSize.x) / CameraMgr.m_ViewWidth);

ret.maxPosX = Mathf.FloorToInt((x + m_HalfGridSize.x) / CameraMgr.m_ViewWidth);

ret.minPosY = Mathf.FloorToInt((y - m_HalfGridSize.y) / CameraMgr.m_ViewHeight);

ret.maxPosY = Mathf.FloorToInt((y + m_HalfGridSize.y) / CameraMgr.m_ViewHeight);

return ret;

}

```

将世界坐标转换为网格坐标范围：

从对象池获取GridRangeInt
将世界坐标范围除以网格大小
使用FloorToInt确保覆盖所有相关网格

碰撞检测

```436:460:Scripts/WeiLai/Mgr/ViewMgr.cs

public static bool CheckCollision(

float rect1MinX, float rect1MinY, float rect1MaxX, float rect1MaxY,

float rect2MinX, float rect2MinY, float rect2MaxX, float rect2MaxY)

{

// 检查x轴是否有重叠

if (rect1MaxX < rect2MinX)

{

return false;

}

if (rect2MaxX < rect1MinX)

{

return false;

}

if (rect1MaxY < rect2MinY)

{

return false;

}

if (rect2MaxY < rect1MinY)

{

return false;

}

return true;

}

```

检查两个矩形是否重叠：

检查X轴是否有重叠
检查Y轴是否有重叠
如果任一轴没有重叠，返回false
否则返回true

总结

这个视野管理系统的主要特点：

**性能优化**：通过网格化视野管理，只渲染视野内的对象
**对象池**：使用对象池减少内存分配
**双重范围**：同时维护整数网格范围和浮点数世界坐标范围
**回调机制**：通过接口回调通知对象进入/退出视野
**缓存机制**：缓存视野内的怪物和场景网格列表

目前大部分功能被禁用了（直接return），可能是为了调试或性能测试。

在C#中，protected override void OnInit() 是一个方法的声明，其中的 protected 和 override 是两个关键修饰符，分别表示 访问权限 和 方法重写。以下是详细解释：

1. protected（访问修饰符）
作用：表示该方法只能在 当前类 或 派生类（子类） 中访问，外部类无法直接调用。
对比其他修饰符：
public：完全公开。

private：仅当前类可访问。
internal：同一程序集内可访问。
cs 复制代码
class BaseClass
{
    protected void ProtectedMethod() { } // 仅基类和子类可调用
}
2. override（方法重写）
作用：表示该方法 重写（覆盖）了父类的虚方法（virtual）或抽象方法（abstract）。
前提条件：
父类中必须存在标记为 virtual 或 abstract 的同名方法。
方法签名（名称、参数、返回类型）必须完全一致。
cs 复制代码
class ParentClass
{
    public virtual void OnInit() { } // 父类虚方法
}

class ChildClass : ParentClass
{
    protected override void OnInit() 
    { 
        base.OnInit(); // 可选：调用父类逻辑
        // 子类新增逻辑
    }
}
3. 为什么需要 protected override？
封装性 ：protected 确保方法只在继承体系内使用，避免外部误调用。

多态性 ：override 允许子类自定义父类行为，实现多态（同一方法在不同子类中有不同实现）。
4. 常见应用场景

框架/游戏生命周期方法 ：

如 Unity 的 OnInit()、ASP.NET Core 的 OnInitialize()，通常由框架基类定义虚方法，子类重写以注入自定义逻辑。

抽象类/接口实现 ：

若父类是抽象类（abstract），子类必须重写抽象方法。

5. 注意事项

new vs override ：

若子类方法用 new 修饰，会隐藏父类方法（而非重写），多态调用时仍执行父类逻辑。

密封方法 ：

若父类方法标记为 sealed override，子类不能再重写。

protected override void OnInit() 的含义：
这是一个受保护的方法，重写了父类的虚方法或抽象方法，允许子类在继承关系中扩展或修改其行为。

典型用途：自定义初始化逻辑 、实现多态 、响应生命周期事件。
List<T> 简介
List<T> 是 .NET 框架中泛型集合类，位于 System.Collections.Generic 命名空间下。

它提供了动态数组的功能，可以存储任意类型的对象，并且在运行时可以根据需要动态调整大小。

PageInfo 类型

PageInfo 是一个自定义类型，通常用于表示 UI 页面的相关信息（例如页面名称、资源路径、是否已加载等）。

该类型可能包含一些属性或方法来管理页面的状态或数据。

UIMgr

循环遍历 m_Caches 列表

使用一个从后往前（倒序）的 for 循环来遍历 m_Caches 列表。

m_Caches 是一个存储 PageInfo 对象的列表，通常用于缓存已经加载过的 UI 页面信息。

倒序遍历的原因可能是为了在删除元素时不影响前面的索引，避免跳过某些元素。

获取当前迭代的页面对象

var page = m_Caches[i];：从 m_Caches 列表中取出索引为 i 的页面对象，并将其赋值给局部变量 page。
这里的 var 关键字表示隐式类型推断，编译器会根据右侧的表达式自动推断出 page 的类型为 PageInfo。

判断页面类型是否匹配
if (page.m_PageType == ePageType)：检查当前页面对象的 m_PageType 属性是否与传入的 ePageType 匹配。
m_PageType 是 PageInfo 类中的一个字段或属性，表示该页面的类型。
ePageType 是一个外部传入的变量，通常是一个枚举值，代表需要查找的目标页面类型。

游戏开发日志

文件结构概览

1. 命名空间和引用

2. 数据结构定义

GridRangeInt 类

GridRangeFloat 类

SkinnerItem 类

3. 接口定义

IRecycleSkinnerMoveable 接口

IRecycleSkinner 接口

4. ViewItem 类

5. ViewMgr 主类

成员变量

初始化方法

可移动对象管理

添加视野对象

移除视野对象

视野检查

添加视野内项目

检查可移动对象

核心视野检查逻辑

获取视野内对象

清理方法

6. ViewTools 工具类

静态变量

网格坐标转换

获取网格大小

获取世界坐标范围

获取网格范围

碰撞检测

总结

1. `protected`（访问修饰符）

2. `override`（方法重写）

3. 为什么需要 `protected override`？

4. 常见应用场景

5. 注意事项

UIMgr

游戏开发日志

文件结构概览

1. 命名空间和引用

2. 数据结构定义

GridRangeInt 类

GridRangeFloat 类

SkinnerItem 类

3. 接口定义

IRecycleSkinnerMoveable 接口

IRecycleSkinner 接口

4. ViewItem 类

5. ViewMgr 主类

成员变量

初始化方法

可移动对象管理

添加视野对象

移除视野对象

视野检查

添加视野内项目

检查可移动对象

核心视野检查逻辑

获取视野内对象

清理方法

6. ViewTools 工具类

静态变量

网格坐标转换

获取网格大小

获取世界坐标范围

获取网格范围

碰撞检测

总结

1. protected（访问修饰符）

2. override（方法重写）

3. 为什么需要 protected override？

4. 常见应用场景

5. 注意事项

UIMgr

1. `protected`（访问修饰符）

2. `override`（方法重写）

3. 为什么需要 `protected override`？