/// <summary>
/// 初始化
/// </summary>
/// <param name="gamingMapuid"></param>
/// <param name="mapId"></param>
/// <param name="mapName"></param>
/// <param name="mapType"></param>
/// <param name="areaSpawners"></param>
public void Init(uint gamingMapuid, uint mapId, string mapName, GamingMapType mapType, List <AreaSpawner> areaSpawners)
{
m_Uid = gamingMapuid;
m_MapId = mapId;
m_MapName = mapName;
m_Type = mapType;
string areaTemplete = "";
GamingMapEditorSetting gamingSetting = GamingMapEditorUtility.GetGamingMapEditorSetting();
if (gamingSetting != null)
{
areaTemplete = gamingSetting.m_GamingAreaTemplete;
}
GameObject areaTempleteAsset = AssetDatabase.LoadAssetAtPath <GameObject>(areaTemplete);
if (areaTempleteAsset == null)
{
Debug.LogError("GamingMap Area 模板未设置");
return;
}
if (areaSpawners != null && areaSpawners.Count > 0)
{
m_GamingAreaList = new List <GamingMapArea>();
for (int iArea = 0; iArea < areaSpawners.Count; iArea++)
{
AreaSpawner areaSpawner = areaSpawners[iArea];
CreateGamingArea(areaSpawner);
}
}
SaveScene();
}
/// <summary>
/// 调整Transform
/// </summary>
/// <param name="areaSpawner"></param>
public void AdjustTransform(AreaSpawner areaSpawner)
{
if (areaSpawner != null)
{
transform.position = areaSpawner.GetAreaPosition();
transform.rotation = areaSpawner.GetAreaRotation();
}
}
protected override IEnumerator DoExport()
{
List <AreaSpawner> areaSpawnerList = m_Map.GetAreaSpawnerList();
if (areaSpawnerList != null && areaSpawnerList.Count > 0)
{
for (int iArea = 0; iArea < areaSpawnerList.Count; iArea++)
{
AreaSpawner areaSpawner = areaSpawnerList[iArea];
if (areaSpawner != null)
{
if (m_ExportAreaIds != null && m_ExportAreaIds.Contains(areaSpawner.GetAreaId()))
{
m_GamingMap.LoadGamingMapArea(areaSpawner, false);
}
yield return(null);
}
}
}
yield return(null);
m_GamingMap.InitGamingArea();
yield return(null);
m_GamingMap.BeginExport();
yield return(null);
IEnumerator updateAreaEnum = m_GamingMap.UpdataGamingAreas(true);
if (updateAreaEnum != null)
{
while (updateAreaEnum.MoveNext())
{
yield return(null);
}
}
yield return(null);
//刷新LeapOverview
if (m_GamingMap.m_LeapOverview != null)
{
IEnumerator leapOverviewUpdate = m_GamingMap.m_LeapOverview.OnUpdate(m_GamingMap);
if (leapOverviewUpdate != null)
{
while (leapOverviewUpdate != null && leapOverviewUpdate.MoveNext())
{
yield return(null);
}
}
}
yield return(null);
EditorGamingMapData.SaveGamingMapToJson(m_GamingMap, m_ExportAreaIds);
yield return(null);
m_GamingMap.EndExport();
yield return(null);
}
private IEnumerator ExportToJson(GamingMap gamingMap, Map map)
{
List <AreaSpawner> areaSpawnerList = map.GetAreaSpawnerList();
if (areaSpawnerList != null && areaSpawnerList.Count > 0)
{
for (int iArea = 0; iArea < areaSpawnerList.Count; iArea++)
{
AreaSpawner areaSpawner = areaSpawnerList[iArea];
if (areaSpawner != null)
{
LoadGamingMapArea(areaSpawner, false);
yield return(null);
}
}
}
yield return(null);
InitGamingArea();
yield return(null);
BeginExport();
yield return(null);
IEnumerator updateAreaEnum = UpdataGamingAreas(true);
if (updateAreaEnum != null)
{
while (updateAreaEnum.MoveNext())
{
yield return(null);
}
}
yield return(null);
//刷新LeapOverview
if (m_LeapOverview != null)
{
IEnumerator leapOverviewUpdate = m_LeapOverview.OnUpdate(this);
if (leapOverviewUpdate != null)
{
while (leapOverviewUpdate != null && leapOverviewUpdate.MoveNext())
{
yield return(null);
}
}
}
yield return(null);
EditorGamingMapData.SaveGamingMapToJson(gamingMap);
yield return(null);
gamingMap.EndExport();
yield return(null);
m_ExporterGamingMapHandle.IsDone = true;
}
public IEnumerator StartGenerate(Map map, AreaSpawner areaSpawner)
{
InitInfo(map, areaSpawner);
IEnumerator analyzeAreaEnumerator = DoAnalyzeArea(map, areaSpawner, false);
while (analyzeAreaEnumerator.MoveNext())
{
yield return(null);
}
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="areaId"></param>
public void Init(AreaSpawner areaSpawner, GamingMap map)
{
m_GamingMap = map;
m_AreaId = areaSpawner.GetAreaId();
//gameObject.name = string.Format("Area_{0}", m_AreaId);
//gameObject.name = string.Format("Area_{0}", m_AreaName);
gameObject.name = string.Format("{0}_{1}", m_AreaName, m_AreaId);
AdjustTransform(areaSpawner);
RefreshAreaInfo();
}
public IEnumerator DoUpdate_Co(Map map, int indexInMap, bool isExporting, AreaSpawner areaSpawner = null)
{
m_Leap = GetComponentInChildren <MapLeap>();
m_TreasureRoot = GetComponentInChildren <TreasureRootMark>();
if (m_TreasureRoot != null)
{
IEnumerator treasureEnumerator = m_TreasureRoot.DoUpdate();
if (treasureEnumerator != null)
{
while (treasureEnumerator.MoveNext())
{
yield return(null);
}
}
}
yield return(null);
map.LoadExtenInfo(this);
m_MineralRoot = GetComponentInChildren <MineralRootMark>();
if (m_MineralRoot != null)
{
IEnumerator mineralEnumerator = m_MineralRoot.DoUpdate();
if (mineralEnumerator != null)
{
while (mineralEnumerator.MoveNext())
{
yield return(null);
}
}
}
yield return(null);
if (m_Leap != null)
{
m_Leap.DoUpdate(areaSpawner.m_AreaUid);
}
m_OwnerMap = map;
m_OwnerAreaSpawner = areaSpawner;
transform.localScale = Vector3.one; // 美术说Area不会有缩放
if (m_OwnerAreaSpawner != null)
{
gameObject.name = m_OwnerAreaSpawner.GetAreaSpawnObjName();
}
Bounds areaAABB = new Bounds();
MapEditorUtility.CaculateAABB(transform, ref areaAABB, isExporting);
m_AABB = areaAABB;
m_Diameter = MathUtility.CaculateDiagonal(m_AABB);
if (VoxelGrid != null)
{
VoxelGrid.DoUpdate(m_AABB);
}
_Debug.DoUpdate(this);
}
private IEnumerator DoAnalyzeArea(Map map, AreaSpawner areaSpawner, bool showDialog = true)
{
string areaName = areaSpawner.GetAreaScenePath();
Area exportArea = null;
Scene areaScene = EditorSceneManager.OpenScene(areaName, OpenSceneMode.Additive);
if (areaScene != null)
{
SceneManager.SetActiveScene(areaScene);
GameObject[] rootObjArray = areaScene.GetRootGameObjects();
if (rootObjArray != null && rootObjArray.Length > 0)
{
for (int index = 0; index < rootObjArray.Length; index++)
{
SceneManager.MoveGameObjectToScene(rootObjArray[index], map.GetOwnerScene());
Area area = rootObjArray[index].GetComponent <Area>();
if (area != null)
{
exportArea = area;
}
}
}
EditorSceneManager.CloseScene(areaScene, true);
}
yield return(null);
if (exportArea != null)
{
areaSpawner.SetArea(exportArea);
IEnumerator areaSpawnerEnumerator = areaSpawner.DoUpdate(map, true);
while (areaSpawnerEnumerator.MoveNext())
{
yield return(null);
}
//TODO: 1、计算area的直径 2、计算所有unit的直径 3、算出推荐格子大小 对应层AABB范围
//如果大于等于Area直径的90%以上的unit数量大于0 算一个层
Bounds areaAABB = exportArea.GetAABB();
float areaDiameter = Mathf.Max(areaAABB.size.x, areaAABB.size.y, areaAABB.size.z);
float consultDiameter = areaDiameter * 0.9f;
CalcuateLayer(map, exportArea, areaDiameter);
EditorUtility.SetDirty(m_EditorSplitAreaSetting);
GameObject.DestroyImmediate(exportArea.gameObject);
}
EditorUtility.ClearProgressBar();
if (showDialog)
{
EditorUtility.DisplayDialog("Analyze", "分析成功", "OK");
}
AssetDatabase.Refresh();
}
/// <summary>
/// 加载所有的Area
/// </summary>
/// <param name="map"></param>
private void LoadAllArea(Map map)
{
List <AreaSpawner> areaSpawnerList = map.GetAreaSpawnerList();
if (areaSpawnerList == null || areaSpawnerList.Count <= 0)
{
return;
}
for (int iArea = 0; iArea < areaSpawnerList.Count; iArea++)
{
AreaSpawner areaSpawner = areaSpawnerList[iArea];
if (areaSpawner != null)
{
LoadGamingMapArea(areaSpawner, false);
}
}
}
protected override IEnumerator DoExport()
{
DontDestroyAtExport[] exports = UnityEngine.Object.FindObjectsOfType <DontDestroyAtExport>();
if (exports != null && exports.Length > 0)
{
for (int iExport = 0; iExport < exports.Length; iExport++)
{
DontDestroyAtExport export = exports[iExport];
export.gameObject.SetActive(false);
}
}
yield return(null);
List <AreaSpawner> areaSpawners = m_Map.GetAreaSpawnerList();
if (areaSpawners != null && areaSpawners.Count > 0)
{
for (int iArea = 0; iArea < areaSpawners.Count; iArea++)
{
AreaSpawner areaSpawner = areaSpawners[iArea];
IEnumerator areaUpdateEnum = areaSpawner.DoUpdate(m_Map, false);
while (areaUpdateEnum.MoveNext())
{
yield return(null);
}
}
}
IEnumerator loadAllAreaEnumerator = m_Map.LoadAllArea(true);
while (loadAllAreaEnumerator.MoveNext())
{
yield return(null);
}
IEnumerator export3DNavMeshEnum = EditorGamingMapData.Export3DNavMesh(m_SceneCutSize, m_Map);
while (export3DNavMeshEnum.MoveNext())
{
yield return(null);
}
}
/// <summary>
/// 点击区域响应
/// </summary>
/// <param name="selectIndex"></param>
private void OnClickArea(int selectIndex, Map map)
{
if (selectIndex < 2 || map == null)
{
return;
}
List <AreaSpawner> areaSpawnerList = map.GetAreaSpawnerList();
if (areaSpawnerList == null || areaSpawnerList.Count < selectIndex - 1)
{
return;
}
AreaSpawner areaSpawner = areaSpawnerList[selectIndex - 2];
if (areaSpawner != null)
{
areaSpawner.LoadArea();
//TODO:加载对应的GamingMapArea
LoadGamingMapArea(areaSpawner);
}
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="area"></param>
/// <param name="map"></param>
public void Init(EditorArea area, GamingMap map)
{
m_GamingMap = map;
m_AreaId = area.areaId;
m_EditorArea = area;
m_AreaName = area.areaName;
m_AreaType = (AreaType)area.areaType;
m_FatherArea = area.fatherArea;
m_RelieveCreatue = area.relieveCreature;
if (area.childrenAreaList != null && area.childrenAreaList.Length > 0)
{
m_ChildAreas = new List <ulong>();
for (int iChild = 0; iChild < area.childrenAreaList.Length; iChild++)
{
m_ChildAreas.Add(area.childrenAreaList[iChild]);
}
}
else
{
m_ChildAreas = null;
}
//gameObject.name = string.Format("Area_{0}", m_AreaName);
gameObject.name = string.Format("{0}_{1}", m_AreaName, m_AreaId);
AreaSpawner areaSpawner = map.GetAreaSpawner(m_AreaId);
AdjustTransform(areaSpawner);
if (m_EditorArea != null)
{
CreateRoots(m_EditorArea);
m_EditorArea = null;
}
if (area.sceneMissionReleaseId != null && area.sceneMissionReleaseId.Length > 0)
{
m_MissionList = new List <int>(area.sceneMissionReleaseId);
}
}
/// <summary>
/// 创建GameArea
/// </summary>
/// <param name="areaSpawner"></param>
private void CreateGamingArea(AreaSpawner areaSpawner)
{
string areaTemplete = "";
GamingMapEditorSetting gamingSetting = GamingMapEditorUtility.GetGamingMapEditorSetting();
if (gamingSetting != null)
{
areaTemplete = gamingSetting.m_GamingAreaTemplete;
}
GameObject areaTempleteAsset = AssetDatabase.LoadAssetAtPath <GameObject>(areaTemplete);
GameObject obj = Instantiate(areaTempleteAsset);
obj.name = string.Format("Area_{0}", areaSpawner.GetAreaId());
obj.transform.SetParent(transform);
GamingMapArea area = obj.GetComponent <GamingMapArea>();
if (area == null)
{
area = obj.AddComponent <GamingMapArea>();
}
area.Init(areaSpawner, this);
m_GamingAreaList.Add(area);
}
/// <summary>
/// 刷新GamingMap ui
/// </summary>
/// <param name="map"></param>
private void RefreshMapUI(GamingMap gamingMap)
{
if (gamingMap == null)
{
return;
}
m_ContentCache.Clear();
m_ContentCache.Add(new GUIContent("导出数据到json"));
m_ContentCache.Add(new GUIContent("保存"));
Scene scene = gamingMap.GetMapScene();
if (!scene.isLoaded)
{
gamingMap.OpenMapScene();
}
Map map = null;
GameObject[] rootObjs = scene.GetRootGameObjects();
if (rootObjs != null && rootObjs.Length > 0)
{
for (int iRoot = 0; iRoot < rootObjs.Length; iRoot++)
{
GameObject obj = rootObjs[iRoot];
map = obj.GetComponent <Map>();
if (map != null)
{
break;
}
}
}
if (map != null)
{
List <AreaSpawner> areaSpawnerList = map.GetAreaSpawnerList();
if (areaSpawnerList != null && areaSpawnerList.Count > 0)
{
for (int iArea = 0; iArea < areaSpawnerList.Count; iArea++)
{
AreaSpawner areaSpawner = areaSpawnerList[iArea];
GUIContent content = new GUIContent(string.Format("区域/GamingArea_{0}", areaSpawner.GetAreaId()));
m_ContentCache.Add(content);
}
}
}
Vector2 mousePosition = Event.current.mousePosition;
GameObject userData = Selection.activeGameObject;
int selected = -1;
EditorUtility.DisplayCustomMenu(new Rect(mousePosition.x, mousePosition.y, 0, 0), m_ContentCache.ToArray(), selected,
delegate(object data, string[] opt, int select)
{
switch (select)
{
case 0:
//BeginExportGamingMap(gamingMap,map);
List <ulong> areaIds = new List <ulong>();
List <Leap> allLeaps = m_LeapOverview.m_LeapList;
if (allLeaps != null && allLeaps.Count > 0)
{
for (int iLeap = 0; iLeap < allLeaps.Count; iLeap++)
{
if (allLeaps[iLeap].m_IsExportToJson)
{
areaIds.Add(allLeaps[iLeap].m_LeapId);
}
}
}
new ExportGamingMapData().BeginExport(map, gamingMap, areaIds);
break;
case 1: //保存
gamingMap.SaveScene();
break;
default:
gamingMap.OnClickArea(select, map);
break;
}
}, userData);
Event.current.Use();
}
public IEnumerator GenerateAreaDecorate(EditorCollider outData, List <EditorDecorate> editorDecorateList)
{
if (m_Map.m_AreaSpawnerCache != null && m_Map.m_AreaSpawnerCache.Count > 0)
{
EditorColliderArea[] areaList = new EditorColliderArea[m_Map.m_AreaSpawnerCache.Count];
outData.areaList = areaList;
List <GameObject> prefabList = new List <GameObject>();
for (int iArea = 0; iArea < m_Map.m_AreaSpawnerCache.Count; iArea++)
{
editorDecorateList.Clear();
EditorColliderArea editorArea = new EditorColliderArea();
areaList[iArea] = editorArea;
AreaSpawner areaSpawner = m_Map.m_AreaSpawnerCache[iArea];
Area area = areaSpawner.GetArea();
string areaName = areaSpawner.GetAreaScenePath();
while (!string.IsNullOrEmpty(areaName) && area == null)
{
area = areaSpawner.GetArea();
yield return(null);
}
editorArea.areaId = areaSpawner.GetAreaId();
if (area != null)
{
EditorGamingMapData.CorrectAreaColliderCenter(area);
yield return(null);
yield return(null);
prefabList.Clear();
MapEditorUtility.GetAllPrefab(area.transform, prefabList);
if (prefabList != null && prefabList.Count > 0)
{
for (int iUnit = 0; iUnit < prefabList.Count; iUnit++)
{
GameObject unit = prefabList[iUnit];
List <Transform> colliderRoots = MapEditorUtility.FindChilds <Transform>(unit.transform, "Collider");
if (colliderRoots == null || colliderRoots.Count <= 0)
{
continue;
}
for (int iRoot = 0; iRoot < colliderRoots.Count; iRoot++)
{
Transform colliderRoot = colliderRoots[iRoot];
if (colliderRoot != null)
{
Collider[] colliders = colliderRoot.GetComponentsInChildren <Collider>();
if (colliders != null && colliders.Length > 0)
{
for (int iCollider = 0; iCollider < colliders.Length; iCollider++)
{
EditorUtility.DisplayProgressBar("GenerateAreaDecorate", string.Format("{0} {1}", area.name, colliders[iCollider].gameObject.name), (iArea + 1) * 1.0f / m_Map.m_AreaSpawnerCache.Count);
Quaternion rot = colliders[iCollider].transform.rotation;
colliders[iCollider].transform.rotation = Quaternion.identity;
yield return(null);
EditorDecorate decorate = EditorGamingMapData.SaveColliderData(colliders[iCollider], rot, true);
yield return(null);
colliders[iCollider].transform.rotation = rot;
if (decorate != null)
{
decorate.id = m_AutoId++;
editorDecorateList.Add(decorate);
}
CheckColliderLayer(colliders[iCollider]);
}
}
}
}
}
}
editorArea.decorateList = editorDecorateList.ToArray();
}
else
{
Debug.LogError(string.Format("Area {0} 未加载进来", areaSpawner.GetAreaId()));
}
yield return(null);
EditorUtility.ClearProgressBar();
}
}
}
protected override IEnumerator DoExport()
{
List <AreaSpawner> areaSpawners = m_Map.GetAreaSpawnerList();
if (areaSpawners != null && areaSpawners.Count > 0)
{
for (int iArea = 0; iArea < areaSpawners.Count; iArea++)
{
AreaSpawner areaSpawner = areaSpawners[iArea];
IEnumerator areaUpdateEnum = areaSpawner.DoUpdate(m_Map, false);
while (areaUpdateEnum.MoveNext())
{
yield return(null);
}
}
}
IEnumerator loadAreaEnumerator = m_Map.LoadAllArea();
while (loadAreaEnumerator.MoveNext())
{
yield return(null);
}
EditorCollider outData = new EditorCollider();
List <EditorDecorate> editorDecorateList = new List <EditorDecorate>();
m_AutoId = 1;
IEnumerator residentColliderEnumerator = GenerateAreaDecorate(outData, editorDecorateList);
while (residentColliderEnumerator.MoveNext())
{
yield return(null);
}
//常驻collider导出
editorDecorateList.Clear();
IEnumerator areaColliderEnumerator = GenerateResidentDecorate(editorDecorateList);
while (areaColliderEnumerator.MoveNext())
{
yield return(null);
}
outData.mapID = m_Map.Uid;
outData.commondecorateList = editorDecorateList.ToArray();
EditorGamingMapData.SaveColliderToJson(outData);
yield return(null);
Area[] areaArray = UnityEngine.Object.FindObjectsOfType <Area>();
if (areaArray != null && areaArray.Length > 0)
{
for (int iArea = areaArray.Length - 1; iArea >= 0; iArea--)
{
GameObject.DestroyImmediate(areaArray[iArea].gameObject);
if (iArea % 10 == 0)
{
yield return(null);
}
}
}
}
private void InitInfo(Map map, AreaSpawner areaSpawner)
{
InitInfo(map, areaSpawner.m_AreaUid);
}
public void LoadGamingMapArea(AreaSpawner areaSpawner, bool closeOtherArea = true)
{
if (areaSpawner == null)
{
return;
}
string m_AreaScenePath = string.Format("{0}/GamingMapArea_{1}_{2}.unity", GetOwnerAreaPath(), m_Uid, areaSpawner.GetAreaId());
if (string.IsNullOrEmpty(m_AreaScenePath))
{
Debug.LogError("m_AreaScenePath == null");
return;
}
GamingMapArea[] areaArray = UnityEngine.Object.FindObjectsOfType <GamingMapArea>();
if (areaArray != null && areaArray.Length > 0)
{
for (int iArea = 0; iArea < areaArray.Length; iArea++)
{
GamingMapArea area = areaArray[iArea];
if (area != null && area.m_AreaId == areaSpawner.GetAreaId())
{
//Debug.LogError(string.Format("{0}Area已导入", area.m_AreaId));
return;
}
}
}
if (closeOtherArea)
{
SaveOtherGamingArea();
}
string areaScenePath = m_AreaScenePath.Replace("Assets", Application.dataPath);
Scene areaScene;
if (!File.Exists(areaScenePath))
{
string gamingAreaPath = "";
GamingMapEditorSetting gamingSetting = GamingMapEditorUtility.GetGamingMapEditorSetting();
if (gamingSetting != null)
{
gamingAreaPath = gamingSetting.m_GamingAreaTemplete;
}
areaScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Additive);
GameObject areaTempleteAsset = AssetDatabase.LoadAssetAtPath <GameObject>(gamingAreaPath);
GameObject gamingArea = GameObject.Instantiate(areaTempleteAsset);
GamingMapArea mapArea = gamingArea.GetComponent <GamingMapArea>();
mapArea.Init(areaSpawner, this);
EditorSceneManager.MoveGameObjectToScene(gamingArea, areaScene);
EditorSceneManager.SaveScene(areaScene, m_AreaScenePath);
EditorSceneManager.CloseScene(areaScene, true);
AssetDatabase.Refresh();
}
areaScene = EditorSceneManager.OpenScene(m_AreaScenePath, OpenSceneMode.Additive);
if (areaScene != null)
{
GamingMapArea mapArea = null;
GameObject[] rootObjs = areaScene.GetRootGameObjects();
if (rootObjs != null && rootObjs.Length > 0)
{
for (int rIndex = 0; rIndex < rootObjs.Length; rIndex++)
{
mapArea = rootObjs[rIndex].GetComponent <GamingMapArea>();
if (mapArea != null)
{
break;
}
}
}
if (mapArea != null)
{
EditorSceneManager.MoveGameObjectToScene(mapArea.gameObject, GetOwnerScene());
mapArea.transform.SetParent(transform);
}
EditorSceneManager.CloseScene(areaScene, true);
}
}
public void Start(Map map, AreaSpawner areaSpawner)
{
InitInfo(map, areaSpawner);
m_AnalyzeEnumerator = DoAnalyzeArea(map, areaSpawner);
EditorApplication.update += OnUpdate;
}
