1072 lines
32 KiB
C#
1072 lines
32 KiB
C#
using HxGame;
|
|
using HxGame.Data;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
public partial class MapManager : MonoBehaviour
|
|
{
|
|
public enum EditCellType
|
|
{
|
|
None,
|
|
ReturnCell, //回城点
|
|
TeleportCell, //传送点
|
|
NpcCell, //NPC
|
|
PathNodeCell, //路点
|
|
NpcPath, //npc巡逻路径
|
|
MonsterPath, //怪物巡逻路径
|
|
AudioTrigger, //音效触发
|
|
TriggerCell, //触发点
|
|
ReliveCell, //复活点
|
|
SellArea, //摆摊区
|
|
MonsterArea, //怪物
|
|
FuBenArea, //副本
|
|
JuBaoArea, //聚宝
|
|
}
|
|
|
|
public struct CenterPoint
|
|
{
|
|
public int areaIdx;
|
|
public int radius; //半径
|
|
}
|
|
|
|
public struct TriggerPoint
|
|
{
|
|
public int areaIdx;
|
|
public int radius; //半径
|
|
public string text;
|
|
}
|
|
|
|
public struct MonsterPoint
|
|
{
|
|
public int areaIdx;
|
|
public int radius; //半径
|
|
public int id; //刷怪ID
|
|
public int num; //刷怪数量
|
|
}
|
|
|
|
//记录已生成的地形网格
|
|
private List<string> _activeTerrainCells = new List<string>();
|
|
private const int IGNORECELLSIZE = 15;
|
|
private EditCellType _curEditCellType = EditCellType.None;
|
|
|
|
private int _teleportPointSize = 0; //传送点个数
|
|
private int _curTeleportPointIdx = 0; //当前编辑传送点索引
|
|
|
|
private int _npcPointSize = 0; //npc个数
|
|
private int _curNpcPointIdx = 0; //当前编辑npc索引
|
|
|
|
private int _pathNodePointSize = 0; //路点个数
|
|
private int _curPathNodePointIdx = 0; //当前编辑路点索引
|
|
|
|
private int _triggerPointSize = 0; //触发点个数
|
|
private int _curTriggerPointIdx = 0; //当前编辑触发点索引
|
|
|
|
//npc路径数量map
|
|
private Dictionary<int, int> _dicNpcPathPointSize = new Dictionary<int, int>();
|
|
//怪物路径数量map
|
|
private Dictionary<int, int> _dicMonsterPathPointSize = new Dictionary<int, int>();
|
|
|
|
private CenterPoint _curAudioTriggerCenterPoint = new CenterPoint(); //当前编辑音效区索引
|
|
private TriggerPoint _curTriggerCenterPoint = new TriggerPoint(); //当前编辑触发区索引
|
|
private CenterPoint _curReliveCenterPoint = new CenterPoint(); //当前编辑复活点索引
|
|
private CenterPoint _curSellAreaCenterPoint = new CenterPoint(); //当前编辑摆摊区索引
|
|
private MonsterPoint _curMonsterPoint = new MonsterPoint(); //刷怪索引
|
|
private MonsterPoint _curFuBenPoint = new MonsterPoint(); //副本刷怪索引
|
|
private MonsterPoint _curJuBaoPoint = new MonsterPoint(); //聚宝索引
|
|
|
|
public CellNode[] cellsNode;
|
|
|
|
private Dictionary<CellType, List<GameObject>> _layCellsMap = new Dictionary<CellType, List<GameObject>>();
|
|
|
|
public void SetEditCellType(EditCellType type)
|
|
{
|
|
if(cellsNode == null || cellsNode.Length == 0)
|
|
{
|
|
UIWindow.Instance.ShowMessage("请先显示格子");
|
|
return;
|
|
}
|
|
|
|
_curEditCellType = type;
|
|
}
|
|
|
|
//传送点
|
|
public int AddTeleportPointSize()
|
|
{
|
|
return ++_teleportPointSize;
|
|
}
|
|
public void RemoveTeleportPointSize(int idx)
|
|
{
|
|
_curTeleportPointIdx = idx;
|
|
RemoveSpecialPoint(EditCellType.TeleportCell);
|
|
}
|
|
public void SetCurTeleportPointIdx(int idx)
|
|
{
|
|
_curTeleportPointIdx = idx;
|
|
}
|
|
|
|
|
|
//NPC
|
|
public int AddNpcPointSize()
|
|
{
|
|
return ++_npcPointSize;
|
|
}
|
|
public void RemoveNpcPointSize(int idx)
|
|
{
|
|
_curNpcPointIdx = idx;
|
|
RemoveSpecialPoint(EditCellType.NpcCell);
|
|
//还要删除该npc路径
|
|
int size = _dicNpcPathPointSize[_curNpcPointIdx];
|
|
for (int i = 1; i <= size; i++)
|
|
{
|
|
RemoveSpecialPoint(EditCellType.NpcPath, i);
|
|
}
|
|
}
|
|
public void SetCurNpcPointIdx(int idx)
|
|
{
|
|
_curNpcPointIdx = idx;
|
|
}
|
|
|
|
//路点
|
|
public void ZeroNodePathSize()
|
|
{
|
|
_pathNodePointSize = 0;
|
|
}
|
|
public int AddPathNodePointSize()
|
|
{
|
|
return ++_pathNodePointSize;
|
|
}
|
|
public void RemovePathNodePointSize(int idx)
|
|
{
|
|
_curPathNodePointIdx = idx;
|
|
RemoveSpecialPoint(EditCellType.PathNodeCell);
|
|
}
|
|
public void SetCurPathNodePointIdx(int idx)
|
|
{
|
|
_curPathNodePointIdx = idx;
|
|
}
|
|
|
|
//音效触发
|
|
public void SetCurAudioTriggerCenterPoint(int idx, int radius)
|
|
{
|
|
_curAudioTriggerCenterPoint.areaIdx = idx;
|
|
_curAudioTriggerCenterPoint.radius = radius;
|
|
}
|
|
public void RemoveAudioTriggerCenterPoint(int idx)
|
|
{
|
|
_curAudioTriggerCenterPoint.areaIdx = idx;
|
|
RemoveSpecialPoint(EditCellType.AudioTrigger);
|
|
}
|
|
|
|
//触发区
|
|
public void SetCurTriggerCenterPoint(int idx, int radius, TriggerMode mode)
|
|
{
|
|
_curTriggerCenterPoint.areaIdx = idx;
|
|
_curTriggerCenterPoint.radius = radius;
|
|
|
|
switch(mode)
|
|
{
|
|
case TriggerMode.KillMonster:
|
|
_curTriggerCenterPoint.text = "杀怪触发";
|
|
break;
|
|
case TriggerMode.UseItem:
|
|
_curTriggerCenterPoint.text = "道具触发";
|
|
break;
|
|
case TriggerMode.Task:
|
|
_curTriggerCenterPoint.text = "任务触发";
|
|
break;
|
|
case TriggerMode.Npc:
|
|
_curTriggerCenterPoint.text = "NPC触发";
|
|
break;
|
|
}
|
|
}
|
|
public void RemoveTriggerCenterPoint(int idx)
|
|
{
|
|
_curTriggerCenterPoint.areaIdx = idx;
|
|
RemoveSpecialPoint(EditCellType.TriggerCell);
|
|
}
|
|
|
|
//复活点
|
|
public void SetReliveCenterPoint(int idx, int radius)
|
|
{
|
|
_curReliveCenterPoint.areaIdx = idx;
|
|
_curReliveCenterPoint.radius = radius;
|
|
}
|
|
public void RemoveReliveCenterPoint(int idx)
|
|
{
|
|
_curReliveCenterPoint.areaIdx = idx;
|
|
RemoveSpecialPoint(EditCellType.ReliveCell);
|
|
}
|
|
|
|
//摆摊区
|
|
public void SetCurSellCenterPoint(int idx, int radius)
|
|
{
|
|
_curSellAreaCenterPoint.areaIdx = idx;
|
|
_curSellAreaCenterPoint.radius = radius;
|
|
}
|
|
public void RemoveSellCenterPoint(int idx)
|
|
{
|
|
_curSellAreaCenterPoint.areaIdx = idx;
|
|
RemoveSpecialPoint(EditCellType.SellArea);
|
|
}
|
|
|
|
//怪物
|
|
public void SetMonsterPoint(int idx, int radius, int id, int num)
|
|
{
|
|
_curMonsterPoint.areaIdx = idx;
|
|
_curMonsterPoint.radius = radius;
|
|
_curMonsterPoint.id = id;
|
|
_curMonsterPoint.num = num;
|
|
}
|
|
|
|
public void RemoveMonsterPoint(int idx)
|
|
{
|
|
_curMonsterPoint.areaIdx = idx;
|
|
RemoveSpecialPoint(EditCellType.MonsterArea);
|
|
//还要删除该npc路径
|
|
if (!_dicMonsterPathPointSize.ContainsKey(_curMonsterPoint.areaIdx))
|
|
return;
|
|
|
|
int size = _dicMonsterPathPointSize[_curMonsterPoint.areaIdx];
|
|
for (int i = 1; i <= size; i++)
|
|
{
|
|
RemoveSpecialPoint(EditCellType.MonsterPath, i);
|
|
}
|
|
}
|
|
|
|
public void ShowMonsterPoint(int idx)
|
|
{
|
|
Transform cellsTrans = UIWindow.Instance.mapTrans.Find("CellsNode");
|
|
if (cellsTrans == null)
|
|
{
|
|
UIWindow.Instance.ShowMessage("没有找到CellsNode节点");
|
|
return;
|
|
}
|
|
|
|
string cellName = $"怪物区{idx}";
|
|
|
|
var t = cellsTrans.Find(cellName);
|
|
if (t == null)
|
|
return;
|
|
|
|
t.gameObject.SetActive(true);
|
|
}
|
|
|
|
public void HideMonsterPoint(int idx)
|
|
{
|
|
Transform cellsTrans = UIWindow.Instance.mapTrans.Find("CellsNode");
|
|
if (cellsTrans == null)
|
|
{
|
|
UIWindow.Instance.ShowMessage("没有找到CellsNode节点");
|
|
return;
|
|
}
|
|
|
|
string cellName = $"怪物区{idx}";
|
|
|
|
var t = cellsTrans.Find(cellName);
|
|
if (t == null)
|
|
return;
|
|
|
|
t.gameObject.SetActive(false);
|
|
}
|
|
|
|
|
|
//npc巡逻路径
|
|
public int AddNpcPathSize()
|
|
{
|
|
if (!_dicNpcPathPointSize.ContainsKey(_curNpcPointIdx))
|
|
return 1;
|
|
|
|
return _dicNpcPathPointSize[_curNpcPointIdx]++;
|
|
}
|
|
public void SetCurNpcPathIdx(int idx)
|
|
{
|
|
if (_dicNpcPathPointSize.ContainsKey(_curNpcPointIdx))
|
|
return;
|
|
|
|
_dicNpcPathPointSize.Add(_curNpcPointIdx, idx);
|
|
}
|
|
public int GetCurNpcPathIdx()
|
|
{
|
|
if (!_dicNpcPathPointSize.ContainsKey(_curNpcPointIdx))
|
|
return 0;
|
|
|
|
return _dicNpcPathPointSize[_curNpcPointIdx];
|
|
}
|
|
|
|
//monster巡逻路径
|
|
public int AddMonsterPathSize()
|
|
{
|
|
if (!_dicMonsterPathPointSize.ContainsKey(_curMonsterPoint.areaIdx))
|
|
return 1;
|
|
|
|
return _dicMonsterPathPointSize[_curMonsterPoint.areaIdx]++;
|
|
}
|
|
public void SetCurMonsterPathIdx(int idx)
|
|
{
|
|
if (_dicMonsterPathPointSize.ContainsKey(_curMonsterPoint.areaIdx))
|
|
return;
|
|
|
|
_dicMonsterPathPointSize.Add(_curMonsterPoint.areaIdx, idx);
|
|
}
|
|
public int GetCurMonsterPathIdx()
|
|
{
|
|
if (!_dicMonsterPathPointSize.ContainsKey(_curMonsterPoint.areaIdx))
|
|
return 0;
|
|
|
|
return _dicMonsterPathPointSize[_curMonsterPoint.areaIdx];
|
|
}
|
|
|
|
//副本刷怪区
|
|
public void SetCurFuBenCenterPoint(int idx, int radius, int id, int num)
|
|
{
|
|
_curFuBenPoint.areaIdx = idx;
|
|
_curFuBenPoint.radius = radius;
|
|
_curFuBenPoint.id = id;
|
|
_curFuBenPoint.num = num;
|
|
}
|
|
public void RemoveFuBenCenterPoint(int idx)
|
|
{
|
|
_curFuBenPoint.areaIdx = idx;
|
|
RemoveSpecialPoint(EditCellType.FuBenArea);
|
|
}
|
|
|
|
//聚宝区
|
|
//public void SetCurJuBaoCenterPoint(int idx, int radius, int id, int num)
|
|
public void SetCurJuBaoCenterPoint(int idx, int radius, int id)
|
|
{
|
|
_curJuBaoPoint.areaIdx = idx;
|
|
_curJuBaoPoint.radius = radius;
|
|
_curJuBaoPoint.id = id;
|
|
}
|
|
|
|
public void RemoveJuBaoCenterPoint(int idx)
|
|
{
|
|
_curJuBaoPoint.areaIdx = idx;
|
|
RemoveSpecialPoint(EditCellType.JuBaoArea);
|
|
}
|
|
|
|
|
|
private string GetSpecialName(EditCellType cellType, out int size)
|
|
{
|
|
size = 0;
|
|
string cellName = string.Empty;
|
|
switch (cellType)
|
|
{
|
|
case EditCellType.TeleportCell:
|
|
cellName = "传送点";
|
|
size = _teleportPointSize;
|
|
break;
|
|
case EditCellType.NpcCell:
|
|
cellName = "Npc";
|
|
size = _npcPointSize;
|
|
break;
|
|
case EditCellType.PathNodeCell:
|
|
cellName = "PathNode";
|
|
size = _pathNodePointSize;
|
|
break;
|
|
case EditCellType.ReliveCell:
|
|
cellName = "复活点";
|
|
size = UIWindow.Instance.uiRelivesPanel.itemParent.childCount;
|
|
break;
|
|
case EditCellType.AudioTrigger:
|
|
cellName = "音效触发";
|
|
size = UIWindow.Instance.uiAudioTriggerPanel.itemParent.childCount;
|
|
break;
|
|
case EditCellType.TriggerCell:
|
|
cellName = "触发区";
|
|
size = UIWindow.Instance.uiTriggersPanel.itemParent.childCount;
|
|
break;
|
|
case EditCellType.SellArea:
|
|
cellName = "摆摊区";
|
|
size = UIWindow.Instance.uiSellAreasPanel.itemParent.childCount;
|
|
break;
|
|
case EditCellType.MonsterArea:
|
|
cellName = "怪物区";
|
|
//size = UIWindow.Instance.uiMonstersPanel_old.itemParent.childCount;
|
|
break;
|
|
case EditCellType.FuBenArea:
|
|
cellName = "副本刷怪";
|
|
size = UIWindow.Instance.uiFuBensPanel.itemParent.childCount;
|
|
break;
|
|
case EditCellType.JuBaoArea:
|
|
cellName = "聚宝区";
|
|
size = UIWindow.Instance.uiFuBensPanel.itemParent.childCount;
|
|
break;
|
|
default:
|
|
return null;
|
|
}
|
|
|
|
return cellName;
|
|
}
|
|
|
|
public void ShowSpecialPoint(EditCellType cellType)
|
|
{
|
|
Transform cellsTrans = UIWindow.Instance.mapTrans.Find("CellsNode");
|
|
if (cellsTrans == null)
|
|
{
|
|
UIWindow.Instance.ShowMessage("没有找到CellsNode节点");
|
|
return;
|
|
}
|
|
|
|
int size = 0;
|
|
string cellName = GetSpecialName(cellType, out size);
|
|
|
|
Transform trans = null;
|
|
for (int i = 1; i <= size; i++)
|
|
{
|
|
trans = cellsTrans.Find($"{cellName}{i}");
|
|
if (trans == null)
|
|
continue;
|
|
|
|
trans.gameObject.SetActive(true);
|
|
}
|
|
|
|
if(cellType == EditCellType.MonsterArea)
|
|
{
|
|
foreach(var item in _dicMonsterPathPointSize)
|
|
{
|
|
for (int i = 1; i <= item.Value; i++)
|
|
{
|
|
cellName = $"MonsterPath{item.Key}{i}";
|
|
trans = cellsTrans.Find(cellName);
|
|
if (trans == null)
|
|
continue;
|
|
|
|
trans.gameObject.SetActive(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void HideSpecialPoint(EditCellType cellType)
|
|
{
|
|
Transform cellsTrans = UIWindow.Instance.mapTrans.Find("CellsNode");
|
|
if (cellsTrans == null)
|
|
{
|
|
UIWindow.Instance.ShowMessage("没有找到CellsNode节点");
|
|
return;
|
|
}
|
|
|
|
int size = 0;
|
|
string cellName = GetSpecialName(cellType, out size);
|
|
|
|
Transform trans = null;
|
|
for(int i=1; i<=size; i++)
|
|
{
|
|
trans = cellsTrans.Find($"{cellName}{i}");
|
|
if (trans == null)
|
|
continue;
|
|
|
|
trans.gameObject.SetActive(false);
|
|
}
|
|
}
|
|
|
|
public void RemoveSpecialPoint(EditCellType cellType, int idx = 0)
|
|
{
|
|
Transform cellsTrans = UIWindow.Instance.mapTrans.Find("CellsNode");
|
|
if (cellsTrans == null)
|
|
{
|
|
UIWindow.Instance.ShowMessage("没有找到CellsNode节点");
|
|
return;
|
|
}
|
|
|
|
string cellName = string.Empty;
|
|
switch (cellType)
|
|
{
|
|
case EditCellType.ReturnCell:
|
|
cellName = "回城点";
|
|
break;
|
|
case EditCellType.TeleportCell:
|
|
cellName = $"传送点{_curTeleportPointIdx}";
|
|
break;
|
|
case EditCellType.NpcCell:
|
|
cellName = $"Npc{_curNpcPointIdx}";
|
|
break;
|
|
case EditCellType.PathNodeCell:
|
|
cellName = $"PathNode{_curPathNodePointIdx}";
|
|
break;
|
|
case EditCellType.ReliveCell:
|
|
cellName = $"复活点{_curReliveCenterPoint.areaIdx}";
|
|
break;
|
|
case EditCellType.AudioTrigger:
|
|
cellName = $"音效触发{_curAudioTriggerCenterPoint.areaIdx}";
|
|
break;
|
|
case EditCellType.TriggerCell:
|
|
cellName = $"Trigger{_curTriggerPointIdx}";
|
|
break;
|
|
case EditCellType.SellArea:
|
|
cellName = $"摆摊区{_curSellAreaCenterPoint.areaIdx}";
|
|
break;
|
|
case EditCellType.MonsterArea:
|
|
cellName = $"怪物区{_curMonsterPoint.areaIdx}";
|
|
break;
|
|
case EditCellType.FuBenArea:
|
|
cellName = $"副本刷怪{_curFuBenPoint.areaIdx}";
|
|
break;
|
|
case EditCellType.JuBaoArea:
|
|
cellName = $"聚宝区{_curJuBaoPoint.areaIdx}";
|
|
break;
|
|
case EditCellType.NpcPath:
|
|
cellName = $"NpcPath{_curNpcPointIdx}{idx}";
|
|
break;
|
|
case EditCellType.MonsterPath:
|
|
cellName = $"MonsterPath{_curMonsterPoint .areaIdx}{idx}";
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
if (cellsTrans.Find(cellName))
|
|
{
|
|
DestroyImmediate(cellsTrans.Find(cellName).gameObject);
|
|
}
|
|
}
|
|
|
|
|
|
public void CreateSpecialPoint(int x, int y, EditCellType cellType)
|
|
{
|
|
Transform cellsTrans = UIWindow.Instance.mapTrans.Find("CellsNode");
|
|
if (cellsTrans == null)
|
|
{
|
|
UIWindow.Instance.ShowMessage("没有找到CellsNode节点");
|
|
return;
|
|
}
|
|
|
|
if (_curOpenMapId <= 0)
|
|
return;
|
|
|
|
if (cellsNode == null)
|
|
return;
|
|
|
|
if (mapWidth <= 0 || mapHeight <= 0)
|
|
return;
|
|
if (_cellWidth <= 0 || _cellHeight <= 0)
|
|
return;
|
|
if (_cellRows <= 0 || _cellCols <= 0)
|
|
return;
|
|
|
|
if (y < 0 || y >= _cellRows)
|
|
return;
|
|
if (x < 0 || x >= _cellCols)
|
|
return;
|
|
|
|
UnityEngine.Object obj = null;
|
|
|
|
|
|
if (cellType < EditCellType.AudioTrigger)
|
|
obj = null;
|
|
else if (cellType == EditCellType.AudioTrigger)
|
|
obj = Resources.Load("Prefabs/audioTriggerCenterPoint");
|
|
else if (cellType == EditCellType.TriggerCell)
|
|
obj = Resources.Load("Prefabs/triggerCenterPoint");
|
|
else if (cellType == EditCellType.ReliveCell)
|
|
obj = Resources.Load("Prefabs/reliveCenterPoint");
|
|
else if (cellType == EditCellType.SellArea)
|
|
obj = Resources.Load("Prefabs/sellCenterPoint");
|
|
else if (cellType == EditCellType.MonsterArea)
|
|
obj = Resources.Load("Prefabs/monsterPoint");
|
|
else if (cellType == EditCellType.FuBenArea)
|
|
obj = Resources.Load("Prefabs/fubenPoint");
|
|
else if (cellType == EditCellType.JuBaoArea)
|
|
obj = Resources.Load("Prefabs/jubaoPoint");
|
|
|
|
if (obj == null)
|
|
{
|
|
UIWindow.Instance.ShowMessage("加载cell.prefab失败");
|
|
return;
|
|
}
|
|
|
|
string cellName = string.Empty;
|
|
Material mat = null;
|
|
Vector3 localScale = Vector3.zero;
|
|
|
|
switch (cellType)
|
|
{
|
|
case EditCellType.ReturnCell:
|
|
cellName = "回城点";
|
|
mat = _cellReturnMat;
|
|
break;
|
|
case EditCellType.TeleportCell:
|
|
cellName = $"传送点{_curTeleportPointIdx}";
|
|
mat = _cellTeleportMat;
|
|
break;
|
|
case EditCellType.NpcCell:
|
|
cellName = $"Npc{_curNpcPointIdx}";
|
|
mat = _cellNpcMat;
|
|
break;
|
|
case EditCellType.PathNodeCell:
|
|
cellName = $"PathNode{_curPathNodePointIdx}";
|
|
mat = _cellPathNodeMat;
|
|
break;
|
|
case EditCellType.AudioTrigger:
|
|
cellName = $"音效触发{_curAudioTriggerCenterPoint.areaIdx}";
|
|
localScale = new Vector3(0.9f * _curAudioTriggerCenterPoint.radius * 2, 0.9f * _curAudioTriggerCenterPoint.radius * 2, 1);
|
|
break;
|
|
case EditCellType.TriggerCell:
|
|
cellName = $"触发区{_curTriggerCenterPoint.areaIdx}";
|
|
localScale = new Vector3(0.9f * _curTriggerCenterPoint.radius * 2, 0.9f * _curTriggerCenterPoint.radius * 2, 1);
|
|
break;
|
|
case EditCellType.ReliveCell:
|
|
cellName = $"复活点{_curReliveCenterPoint.areaIdx}";
|
|
localScale = new Vector3(0.9f * _curReliveCenterPoint.radius * 2, 0.9f * _curReliveCenterPoint.radius * 2, 1);
|
|
break;
|
|
case EditCellType.SellArea:
|
|
cellName = $"摆摊区{_curSellAreaCenterPoint.areaIdx}";
|
|
localScale = new Vector3(0.9f * _curSellAreaCenterPoint.radius * 2, 0.9f * _curSellAreaCenterPoint.radius * 2, 1);
|
|
break;
|
|
case EditCellType.MonsterArea:
|
|
cellName = $"怪物区{_curMonsterPoint.areaIdx}";
|
|
localScale = new Vector3(0.9f * _curMonsterPoint.radius * 2, 0.9f * _curMonsterPoint.radius * 2, 1);
|
|
if (localScale == Vector3.forward)
|
|
localScale = new Vector3(0.5f, 0.5f, 1);
|
|
break;
|
|
case EditCellType.FuBenArea:
|
|
cellName = $"副本刷怪{_curFuBenPoint.areaIdx}";
|
|
localScale = new Vector3(0.9f * _curFuBenPoint.radius * 2, 0.9f * _curFuBenPoint.radius * 2, 1);
|
|
break;
|
|
case EditCellType.JuBaoArea:
|
|
cellName = $"聚宝区{_curJuBaoPoint.areaIdx}";
|
|
localScale = new Vector3(0.9f * _curJuBaoPoint.radius * 2, 0.9f * _curJuBaoPoint.radius * 2, 1);
|
|
break;
|
|
case EditCellType.NpcPath:
|
|
cellName = $"NpcPath{_curNpcPointIdx}{GetCurNpcPathIdx()}";
|
|
mat = _cellPathNodeMat;
|
|
break;
|
|
case EditCellType.MonsterPath:
|
|
cellName = $"MonsterPath{_curMonsterPoint.areaIdx}{GetCurMonsterPathIdx()}";
|
|
mat = _cellPathNodeMat;
|
|
break;
|
|
}
|
|
|
|
GameObject go = null;
|
|
if (cellsTrans.Find(cellName))
|
|
{
|
|
go = cellsTrans.Find(cellName).gameObject;
|
|
}
|
|
else
|
|
{
|
|
go = Instantiate(obj) as GameObject;
|
|
go.transform.SetParent(cellsTrans, false);
|
|
go.transform.localScale = new Vector3(((float)_cellWidth / CELLSCALE) - 0.1f, ((float)_cellHeight / CELLSCALE) - 0.1f, 1);
|
|
}
|
|
|
|
CellNode cell = GetCell(x, y);
|
|
|
|
Vector3 pos = cell.GetPos((float)_cellWidth / CELLSCALE, (float)_cellHeight / CELLSCALE);
|
|
go.transform.localPosition = new Vector3(pos.x, pos.z, pos.y);
|
|
go.name = cellName;
|
|
|
|
if (cellType < EditCellType.AudioTrigger)
|
|
go.GetComponent<MeshRenderer>().material = mat;
|
|
else
|
|
go.transform.localScale = localScale;
|
|
|
|
if(cellType == EditCellType.MonsterArea)
|
|
{
|
|
go.transform.Find("Name").GetComponent<Text>().text = $"怪物区{_curMonsterPoint.areaIdx}";
|
|
go.transform.Find("ID").GetComponent<Text>().text = "ID:" + _curMonsterPoint.id.ToString();
|
|
go.transform.Find("Num").GetComponent<Text>().text = "Num:" + _curMonsterPoint.num.ToString();
|
|
}
|
|
else if (cellType == EditCellType.FuBenArea)
|
|
{
|
|
go.transform.Find("Order").GetComponent<Text>().text = _curFuBenPoint.areaIdx.ToString();
|
|
go.transform.Find("ID").GetComponent<Text>().text = "ID:" + _curFuBenPoint.id.ToString();
|
|
go.transform.Find("Num").GetComponent<Text>().text = "Num:" + _curFuBenPoint.num.ToString();
|
|
}
|
|
else if (cellType == EditCellType.JuBaoArea)
|
|
{
|
|
go.transform.Find("ID").GetComponent<Text>().text = "ID:" + _curJuBaoPoint.id.ToString();
|
|
//go.transform.Find("Num").GetComponent<Text>().text = "Num:" + _curJuBaoPoint.num.ToString();
|
|
}
|
|
else if(cellType == EditCellType.TriggerCell)
|
|
{
|
|
go.transform.GetChild(0).GetComponent<Text>().text = _curTriggerCenterPoint.text;
|
|
}
|
|
|
|
}
|
|
|
|
public int GetLayCellCount(CellType lay)
|
|
{
|
|
if(!_layCellsMap.ContainsKey(lay))
|
|
return 0;
|
|
|
|
return _layCellsMap[lay].Count;
|
|
}
|
|
|
|
public void CreateCells()
|
|
{
|
|
foreach (var key in _layCellsMap.Keys)
|
|
_layCellsMap[key].Clear();
|
|
|
|
Transform cellsTrans = UIWindow.Instance.mapTrans.Find("CellsNode");
|
|
if(cellsTrans == null)
|
|
{
|
|
UIWindow.Instance.ShowMessage("没有找到CellsNode节点");
|
|
return;
|
|
}
|
|
|
|
//有可能创建了回城点等
|
|
if (cellsTrans.childCount > IGNORECELLSIZE)
|
|
{
|
|
SetGameObjectActiveWithAllChild(cellsTrans, true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void HideCells()
|
|
{
|
|
Transform cellsTrans = UIWindow.Instance.mapTrans.Find("CellsNode");
|
|
if (cellsTrans == null)
|
|
{
|
|
UIWindow.Instance.ShowMessage("没有找到CellsNode节点");
|
|
return;
|
|
}
|
|
|
|
SetGameObjectActiveWithAllChild(cellsTrans, false);
|
|
}
|
|
|
|
public void ShowCells()
|
|
{
|
|
Transform cellsTrans = UIWindow.Instance.mapTrans.Find("CellsNode");
|
|
if (cellsTrans == null)
|
|
{
|
|
UIWindow.Instance.ShowMessage("没有找到CellsNode节点");
|
|
return;
|
|
}
|
|
|
|
SetGameObjectActiveWithAllChild(cellsTrans, true);
|
|
}
|
|
|
|
void SetGameObjectActiveWithAllChild(Transform parentTrans, bool bActive)
|
|
{
|
|
for (int i = 0; i < parentTrans.childCount; i++)
|
|
{
|
|
Transform trans = parentTrans.GetChild(i);
|
|
if (trans == null)
|
|
continue;
|
|
|
|
trans.gameObject.SetActive(bActive);
|
|
}
|
|
}
|
|
|
|
public void RemoveAllCells()
|
|
{
|
|
Transform trans = UIWindow.Instance.mapTrans.Find("CellsNode");
|
|
if (trans == null)
|
|
return;
|
|
|
|
int count = trans.childCount;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
DestroyImmediate(trans.GetChild(0).gameObject);
|
|
}
|
|
|
|
Cleanup();
|
|
}
|
|
|
|
public CellNode GetCell(int x, int y)
|
|
{
|
|
if (x < 0 || y < 0)
|
|
return null;
|
|
|
|
if (y >= _cellRows || x >= _cellCols)
|
|
return null;
|
|
|
|
int index = y * _cellCols + x;
|
|
return cellsNode[index];
|
|
}
|
|
|
|
public CellNode GetCell(int index)
|
|
{
|
|
if (index < 0)
|
|
return null;
|
|
|
|
if (index >= cellsNode.Length)
|
|
return null;
|
|
|
|
return cellsNode[index];
|
|
}
|
|
|
|
public CellNode GetCell(Vector3 pos)
|
|
{
|
|
int x = (int)pos.x / _cellWidth;
|
|
int y = (int)pos.z / _cellHeight;
|
|
|
|
return GetCell(x, y);
|
|
}
|
|
|
|
private CellType GetCellType(string cellName)
|
|
{
|
|
string[] tmp = cellName.Split('_');
|
|
if (tmp.Length != 2)
|
|
return CellType.None;
|
|
|
|
int x, y;
|
|
x = Convert.ToInt32(tmp[0]);
|
|
y = Convert.ToInt32(tmp[1]);
|
|
|
|
int index = y * _cellCols + x;
|
|
return cellsNode[index].cellType;
|
|
}
|
|
|
|
private CellType SetCellType(string cellName, CellType type)
|
|
{
|
|
string[] tmp = cellName.Split('_');
|
|
if (tmp.Length != 2)
|
|
return CellType.None;
|
|
|
|
int indexX, indexY;
|
|
indexX = Convert.ToInt32(tmp[0]);
|
|
indexY = Convert.ToInt32(tmp[1]);
|
|
|
|
return SetCellType(indexX, indexY, type);
|
|
}
|
|
|
|
private CellType SetCellType(int indexX, int indexY, CellType type)
|
|
{
|
|
CellNode cell = GetCell(indexX, indexY);
|
|
if (cell == null)
|
|
return CellType.None;
|
|
|
|
if (type == CellType.Safe)
|
|
cell.cellType |= CellType.Safe;
|
|
else
|
|
cell.cellType = type;
|
|
|
|
return cell.cellType;
|
|
}
|
|
|
|
private void ShowCellType(GameObject go, CellType type)
|
|
{
|
|
if ((type & CellType.Safe) == CellType.Safe)
|
|
{
|
|
var materials = new Material[2];
|
|
materials[1] = _cellDefaultMat;
|
|
go.GetComponent<MeshRenderer>().materials = materials;
|
|
}
|
|
|
|
if ((type & CellType.Move) == CellType.Move)
|
|
{
|
|
go.GetComponent<MeshRenderer>().material = _cellMoveMat;
|
|
}
|
|
|
|
if ((type & CellType.Obstacle) == CellType.Obstacle)
|
|
{
|
|
go.GetComponent<MeshRenderer>().material = _cellObsMat;
|
|
}
|
|
|
|
if ((type & CellType.Hide) == CellType.Hide)
|
|
{
|
|
go.GetComponent<MeshRenderer>().material = _cellHideMat;
|
|
}
|
|
|
|
//if ((type & CellType.None) == CellType.None)
|
|
if (type == CellType.None)
|
|
{
|
|
go.GetComponent<MeshRenderer>().material = _cellDefaultMat;
|
|
}
|
|
}
|
|
|
|
public void CalculationCells(int cellWidth, int cellHeight, int mapWidth, int mapHeight)
|
|
{
|
|
//RemoveAllCells();
|
|
|
|
_cellWidth = cellWidth;
|
|
_cellHeight = cellHeight;
|
|
this.mapWidth = mapWidth;
|
|
this.mapHeight = mapHeight;
|
|
|
|
_cellRows = mapHeight / _cellHeight; //行 == 高
|
|
_cellCols = mapWidth / _cellWidth; //列 == 宽
|
|
|
|
cellsNode = new CellNode[_cellRows*_cellCols];
|
|
int index = 0;
|
|
|
|
for(int y=0; y < _cellRows; y++)
|
|
{
|
|
for(int x=0; x < _cellCols; x++)
|
|
{
|
|
index = y * _cellCols + x;
|
|
|
|
cellsNode[index] = new CellNode(x, y, index, CellType.Obstacle);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//根据layer分类添加
|
|
public void AddLayerCell(GameObject go, CellType layer)
|
|
{
|
|
List<GameObject> cells = null;
|
|
|
|
if (((CellType)layer & CellType.Move) == CellType.Move)
|
|
{
|
|
cells = _layCellsMap[CellType.Move];
|
|
cells.Add(go);
|
|
}
|
|
|
|
if (((CellType)layer & CellType.Obstacle) == CellType.Obstacle)
|
|
{
|
|
cells = _layCellsMap[CellType.Obstacle];
|
|
cells.Add(go);
|
|
}
|
|
|
|
if (((CellType)layer & CellType.Hide) == CellType.Hide)
|
|
{
|
|
cells = _layCellsMap[CellType.Hide];
|
|
cells.Add(go);
|
|
}
|
|
|
|
if (((CellType)layer & CellType.Safe) == CellType.Safe)
|
|
{
|
|
cells = _layCellsMap[CellType.Safe];
|
|
cells.Add(go);
|
|
}
|
|
|
|
if (((CellType)layer & CellType.Stall) == CellType.Stall)
|
|
{
|
|
cells = _layCellsMap[CellType.Stall];
|
|
cells.Add(go);
|
|
}
|
|
|
|
if (((CellType)layer & CellType.Audio) == CellType.Audio)
|
|
{
|
|
cells = _layCellsMap[CellType.Audio];
|
|
cells.Add(go);
|
|
}
|
|
|
|
if (((CellType)layer & CellType.Trigger) == CellType.Trigger)
|
|
{
|
|
cells = _layCellsMap[CellType.Trigger];
|
|
cells.Add(go);
|
|
}
|
|
|
|
if (((CellType)layer & CellType.Monster) == CellType.Monster)
|
|
{
|
|
cells = _layCellsMap[CellType.Monster];
|
|
cells.Add(go);
|
|
}
|
|
}
|
|
|
|
public void HideCellsExcludeLayers(int layers)
|
|
{
|
|
if (layers == 0)
|
|
return;
|
|
|
|
if(layers < (int)CellType.Stall)
|
|
{
|
|
bool safeNoHide = ((CellType)layers & CellType.Safe) == CellType.Safe;
|
|
|
|
foreach (var layerCells in _layCellsMap)
|
|
{
|
|
safeNoHide = (layerCells.Key & CellType.Safe) == CellType.Safe;
|
|
if (((int)layerCells.Key & layers) != (int)layerCells.Key)
|
|
{
|
|
HideCellsWithLayer(layerCells.Key, layers, safeNoHide);
|
|
}
|
|
}
|
|
|
|
HideSpecialPoint(EditCellType.SellArea);
|
|
HideSpecialPoint(EditCellType.AudioTrigger);
|
|
HideSpecialPoint(EditCellType.TriggerCell);
|
|
HideSpecialPoint(EditCellType.ReliveCell);
|
|
HideSpecialPoint(EditCellType.FuBenArea);
|
|
HideSpecialPoint(EditCellType.MonsterArea);
|
|
HideSpecialPoint(EditCellType.JuBaoArea);
|
|
}
|
|
else
|
|
{
|
|
//先隐藏所有格子
|
|
HideCells();
|
|
|
|
if(((CellType)layers & CellType.Stall) == CellType.Stall)
|
|
{
|
|
ShowSpecialPoint(EditCellType.SellArea);
|
|
}
|
|
|
|
if (((CellType)layers & CellType.Audio) == CellType.Audio)
|
|
{
|
|
ShowSpecialPoint(EditCellType.AudioTrigger);
|
|
}
|
|
|
|
if (((CellType)layers & CellType.Trigger) == CellType.Trigger)
|
|
{
|
|
ShowSpecialPoint(EditCellType.TriggerCell);
|
|
}
|
|
|
|
if (((CellType)layers & CellType.Monster) == CellType.Monster)
|
|
{
|
|
ShowSpecialPoint(EditCellType.MonsterArea);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public void HideCellsWithLayer(CellType hideLayer, int showLayers, bool safeNoHide)
|
|
{
|
|
var cells = _layCellsMap[hideLayer];
|
|
foreach(var cell in cells)
|
|
{
|
|
CellType ct = GetCellType(cell.name);
|
|
//如果隐藏格子类型属于安全区
|
|
if(safeNoHide)
|
|
{
|
|
//如果有显示格子类型的值，不隐藏
|
|
if (((int)ct & (int)showLayers) == showLayers)
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
//如果隐藏格子类型不属于安全区，但是，显示格子类型又是安全区
|
|
if (((int)ct & (int)showLayers) == showLayers)
|
|
continue;
|
|
}
|
|
//
|
|
// continue;
|
|
|
|
cell.SetActive(false);
|
|
}
|
|
|
|
}
|
|
|
|
public void RemoveLayerCellInLayCellsMap(GameObject go)
|
|
{
|
|
List<GameObject> removeGos = new List<GameObject>();
|
|
foreach(var cells in _layCellsMap.Values)
|
|
{
|
|
GameObject f = cells.Find(cell => cell.name == go.name);
|
|
if (f == null)
|
|
continue;
|
|
|
|
removeGos.Add(f);
|
|
}
|
|
|
|
for(int i=0; i<removeGos.Count; i++)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
public void CleanSafe()
|
|
{
|
|
var cells = _layCellsMap[CellType.Safe];
|
|
if (cells == null)
|
|
return;
|
|
|
|
foreach(var cell in cells)
|
|
{
|
|
if (cell.GetComponent<MeshRenderer>().materials.Length == 2)
|
|
cell.GetComponent<MeshRenderer>().materials = new Material[1];
|
|
|
|
CellType ct = GetCellType(cell.name);
|
|
CellType new_ct = (ct ^= CellType.Safe);
|
|
SetCellType(cell.name, new_ct);
|
|
ShowCellType(cell, new_ct);
|
|
}
|
|
|
|
cells.Clear();
|
|
}
|
|
}
|