/// <summary>
 /// 初始化
 /// </summary>
 public void Initialize(AreaLayerInfo areaLayerInfo, AssetInfo[] assetInfos, AreaController areaController, int unloadRange = 3)
 {
     m_AreaController  = areaController;
     m_UnloadRange     = unloadRange;
     m_AreaLayerInfo   = areaLayerInfo;
     m_GridIndexs      = new Dictionary <long, int>();
     m_LoadedGrids     = new HashSet <Vector3Int>();
     m_NeedLoadGrids   = new List <Vector3Int>();
     m_NeedUnLoadGrids = new List <Vector3Int>();
     m_UnitController  = new UnitController();
     m_UnitController.Initialize(areaLayerInfo.m_Units, assetInfos, m_AreaController);
     //初始化虚拟格子
     if (m_AreaLayerInfo != null)
     {
         List <long> gridIndexs = m_AreaLayerInfo.AreaVirtualGridIndexs;
         if (gridIndexs != null && gridIndexs.Count > 0)
         {
             for (int iGrid = 0; iGrid < gridIndexs.Count; iGrid++)
             {
                 //导出索引时 要有个检查过程 判断是否有重复
                 m_GridIndexs.Add(gridIndexs[iGrid], iGrid);
             }
         }
     }
 }
示例#2
0
 /// <summary>
 /// 初始化区域层
 /// </summary>
 private void InitAreaLayer()
 {
     if (m_AreaDetailInfo == null)
     {
         return;
     }
     if (m_AreaLayerControllers == null)
     {
         m_AreaLayerControllers = new List <AreaLayerController>();
     }
     AreaLayerInfo[] areaLayerInfos = m_AreaDetailInfo.AreaLayerInfos;
     if (areaLayerInfos != null && areaLayerInfos.Length > 0)
     {
         for (int iLayer = 0; iLayer < areaLayerInfos.Length; iLayer++)
         {
             AreaLayerInfo areaLayerInfo = areaLayerInfos[iLayer];
             if (areaLayerInfo == null)
             {
                 continue;
             }
             AreaLayerController areaLayerController = new AreaLayerController();
             areaLayerController.Initialize(areaLayerInfo, m_AreaDetailInfo.AssetInfos, this, areaLayerInfo.m_Offest);
             m_AreaLayerControllers.Add(areaLayerController);
         }
     }
 }
        /// <summary>
        /// 卸载格子
        /// </summary>
        private void DoUnloadGrid()
        {
            if (m_NeedUnLoadGrids != null && m_NeedUnLoadGrids.Count > 0)
            {
                for (int iGrid = 0; iGrid < m_NeedUnLoadGrids.Count; iGrid++)
                {
                    Vector3Int v3Int      = m_NeedUnLoadGrids[iGrid];
                    long       gridHashId = AreaLayerInfo.GetHashCode(v3Int);
                    if (m_GridIndexs.ContainsKey(gridHashId))
                    {
                        int index = m_GridIndexs[gridHashId];

                        if (m_AreaLayerInfo.AreaVirtualGridInfos.Count > index)
                        {
                            AreaVirtualGridInfo gridInfo   = m_AreaLayerInfo.AreaVirtualGridInfos[index];
                            List <int>          unitIndexs = gridInfo.m_UnitIndexs;
                            if (unitIndexs != null && unitIndexs.Count > 0)
                            {
                                for (int iUnit = 0; iUnit < unitIndexs.Count; iUnit++)
                                {
                                    m_UnitController.RemoveUnit(unitIndexs[iUnit]);
                                }
                            }
                        }
                    }
                    else
                    {
                        Debug.LogError("不存在gridHashId:" + gridHashId);
                    }
                }
                m_NeedUnLoadGrids.Clear();
            }
        }
示例#4
0
        /// <summary>
        /// AreaDetialInfo写入二进制文件
        /// </summary>
        /// <param name="binaryFile"></param>
        /// <param name="areaDetailInfo"></param>
        private void WriteAreaDetailInfoBinary(BinaryFile binaryFile)
        {
            BinaryWriter writer = binaryFile.m_Writer;

            AssetInfo[] assetInfos = this.AssetInfos;
            if (assetInfos == null || assetInfos.Length <= 0)
            {
                writer.Write(0);
            }
            else
            {
                writer.Write(assetInfos.Length);
                for (int iAsset = 0; iAsset < assetInfos.Length; iAsset++)
                {
                    AssetInfo assetInfo = assetInfos[iAsset];
                    assetInfo.Serialize(writer);
                }
            }
            AreaLayerInfo[] areaLayerInfos = this.AreaLayerInfos;
            if (areaLayerInfos == null || areaLayerInfos.Length <= 0)
            {
                writer.Write(0);
            }
            else
            {
                writer.Write(areaLayerInfos.Length);
                for (int iLayer = 0; iLayer < areaLayerInfos.Length; iLayer++)
                {
                    AreaLayerInfo layerInfo = areaLayerInfos[iLayer];
                    layerInfo.Serialize(writer);
                }
            }
        }
示例#5
0
        private void OnDrawGizmosSelected()
        {
            if (m_AreaLayerInfos != null && m_AreaLayerInfos.Length > 0)
            {
                for (int iLayer = 0; iLayer < m_AreaLayerInfos.Length; iLayer++)
                {
                    //if(m_ShowLayer[iLayer])
                    {
                        AreaLayerInfo layerInfo = m_AreaLayerInfos[iLayer];
                        if (layerInfo != null)
                        {
                            List <AreaVirtualGridInfo> areaVirtualGridInfos = layerInfo.AreaVirtualGridInfos;
                            if (areaVirtualGridInfos != null && areaVirtualGridInfos.Count > 0)
                            {
                                for (int iArea = 0; iArea < areaVirtualGridInfos.Count; iArea++)
                                {
                                    AreaVirtualGridInfo gridInfo = areaVirtualGridInfos[iArea];
                                    if (m_ShowLayer[iLayer])
                                    {
                                        Gizmos.color = m_Colors[iLayer];
                                        Gizmos.DrawWireCube(gridInfo.m_Position, new Vector3(layerInfo.m_GridSize, layerInfo.m_GridSize, layerInfo.m_GridSize));
                                    }

                                    if (m_ShowUnitAB[iLayer])
                                    {
                                        List <int> unitIndexs = gridInfo.m_UnitIndexs;
                                        if (unitIndexs != null && unitIndexs.Count > 0)
                                        {
                                            for (int iUnit = 0; iUnit < unitIndexs.Count; iUnit++)
                                            {
                                                SceneUnitInfo unitInfo = layerInfo.m_Units[unitIndexs[iUnit]];
                                                Gizmos.color = new Color(1, 1, 1, 0.2f);
                                                Gizmos.DrawWireCube(unitInfo._AABB.center, unitInfo._AABB.size);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
示例#6
0
        public void Deserialize(byte[] bytes)
        {
            if (bytes == null)
            {
                return;
            }

            BinaryFile file = new BinaryFile(System.Text.Encoding.Unicode);

            if (!file.OpenRead(bytes))
            {
                file.Close();
                return;
            }
            BinaryReader reader         = file.m_Reader;
            int          assetInfoCount = reader.ReadInt32();

            if (assetInfoCount > 0)
            {
                AssetInfos = new AssetInfo[assetInfoCount];
                for (int iAsset = 0; iAsset < assetInfoCount; iAsset++)
                {
                    AssetInfo assetInfo = new AssetInfo();
                    assetInfo.DeSerialize(reader);
                    AssetInfos[iAsset] = assetInfo;
                }
            }

            int areaLayerCount = reader.ReadInt32();

            if (areaLayerCount > 0)
            {
                AreaLayerInfos = new AreaLayerInfo[areaLayerCount];
                for (int iLayer = 0; iLayer < areaLayerCount; iLayer++)
                {
                    AreaLayerInfo areaLayerInfo = new AreaLayerInfo();
                    areaLayerInfo.DeSerialize(reader);
                    AreaLayerInfos[iLayer] = areaLayerInfo;
                }
            }

            file.Close();
        }
示例#7
0
        public void ShowSceneUI()
        {
            return;

            if (m_AreaLayerInfos != null && m_AreaLayerInfos.Length > 0)
            {
                for (int iLayer = 0; iLayer < m_AreaLayerInfos.Length; iLayer++)
                {
                    if (m_ShowLayer[iLayer])
                    {
                        AreaLayerInfo layerInfo = m_AreaLayerInfos[iLayer];
                        if (layerInfo != null)
                        {
                            List <AreaVirtualGridInfo> areaVirtualGridInfos = layerInfo.AreaVirtualGridInfos;
                            if (areaVirtualGridInfos != null && areaVirtualGridInfos.Count > 0)
                            {
                                for (int iArea = 0; iArea < areaVirtualGridInfos.Count; iArea++)
                                {
                                    AreaVirtualGridInfo gridInfo   = areaVirtualGridInfos[iArea];
                                    List <int>          unitIndexs = gridInfo.m_UnitIndexs;
                                    if (unitIndexs != null && unitIndexs.Count > 0)
                                    {
                                        for (int iUnit = 0; iUnit < unitIndexs.Count; iUnit++)
                                        {
                                            SceneUnitInfo unitInfo  = layerInfo.m_Units[unitIndexs[iUnit]];
                                            AssetInfo     assetInfo = m_AreaDetailInfo.AssetInfos[unitInfo.AssetIndex];
                                            Handles.Label(unitInfo.LocalPosition, assetInfo.AddressableKey);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 检查能加载的Grid和卸载的grid
        /// </summary>
        private void CheckLoadOrUnLoadGrid()
        {
            //检查可卸载的Grid
            if (m_LoadedGrids != null && m_LoadedGrids.Count > 0)
            {
                m_RemoveLoaded.Clear();
                HashSet <Vector3Int> .Enumerator iter = m_LoadedGrids.GetEnumerator();
                while (iter.MoveNext())
                {
                    Vector3Int gridIndex = iter.Current;
                    int        offestX   = Mathf.Abs(gridIndex.x - m_CurrentPosX);
                    int        offestY   = Mathf.Abs(gridIndex.y - m_CurrentPosY);
                    int        offestZ   = Mathf.Abs(gridIndex.z - m_CurrentPosZ);
                    if (offestX > m_UnloadRange || offestY > m_UnloadRange || offestZ > m_UnloadRange)
                    {
                        m_NeedUnLoadGrids.Add(gridIndex);
                        m_RemoveLoaded.Add(gridIndex);
                        if (m_NeedLoadGrids.Contains(gridIndex))
                        {
                            m_NeedLoadGrids.Remove(gridIndex);
                        }
                    }
                }

                if (m_RemoveLoaded != null && m_RemoveLoaded.Count > 0)
                {
                    for (int iLoad = 0; iLoad < m_RemoveLoaded.Count; iLoad++)
                    {
                        m_LoadedGrids.Remove(m_RemoveLoaded[iLoad]);
                    }
                    m_RemoveLoaded.Clear();
                }
            }
            //检查可加载的Grid
            int minIndexX = -m_UnloadRange + m_CurrentPosX;
            int maxIndexX = m_UnloadRange + m_CurrentPosX;
            int minIndexY = -m_UnloadRange + m_CurrentPosY;
            int maxIndexY = m_UnloadRange + m_CurrentPosY;
            int minIndexZ = -m_UnloadRange + m_CurrentPosZ;
            int maxIndexZ = m_UnloadRange + m_CurrentPosZ;

            minIndexX = Mathf.Max(minIndexX, m_AreaLayerInfo.m_MinIndexX);
            maxIndexX = Mathf.Min(maxIndexX, m_AreaLayerInfo.m_MaxIndexX);

            minIndexY = Mathf.Max(minIndexY, m_AreaLayerInfo.m_MinIndexY);
            maxIndexY = Mathf.Min(maxIndexY, m_AreaLayerInfo.m_MaxIndexY);

            minIndexZ = Mathf.Max(minIndexZ, m_AreaLayerInfo.m_MinIndexZ);
            maxIndexZ = Mathf.Min(maxIndexZ, m_AreaLayerInfo.m_MaxIndexZ);
            for (int iX = minIndexX; iX <= maxIndexX; iX++)
            {
                for (int iY = minIndexY; iY <= maxIndexY; iY++)
                {
                    for (int iZ = minIndexZ; iZ <= maxIndexZ; iZ++)
                    {
                        Vector3Int gridIndex    = new Vector3Int(iX, iY, iZ);
                        long       hashCode     = AreaLayerInfo.GetHashCode(gridIndex);
                        bool       hasGridIndex = m_GridIndexs.ContainsKey(hashCode);
                        if (hasGridIndex)
                        {
                            if (m_LoadedGrids.Add(gridIndex))
                            {
                                m_NeedLoadGrids.Add(gridIndex);
                                if (m_NeedUnLoadGrids.Contains(gridIndex))
                                {
                                    m_NeedUnLoadGrids.Remove(gridIndex);
                                }
                            }
                        }
                    }
                }
            }
        }