Unity-地形编辑器-编辑器拓展功能类

最新推荐文章于 2024-05-02 21:16:35 发布
最新推荐文章于 2024-05-02 21:16:35 发布
阅读量557 收藏
点赞数
分类专栏： Unity 3D
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanxxiao/article/details/106515523
版权 
//==========================
// - FileName:      MapTool.cs         
// - Created:       true.	
// - CreateTime:    2020/04/04 23:37:18	
// - Email:         1670328571@qq.com		
// - Region:        China WUHAN	
// - Description:   编辑器拓展
//==========================
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.IO;


#if Tool
[CustomEditor(typeof(MapMaker))]
public class MapTool : Editor
{
    //对象的引用
    private MapMaker mapMaker; 
    //拿到文件、关卡文件列表
    private List<FileInfo> fileList = new List<FileInfo>();
    //名字列表
    private string[] fileNameList;
    //当前编辑关卡索引号
    private int selectIndex = -1;
    
    public override void OnInspectorGUI()
    {
        //添加的东西写在下方
        base.OnInspectorGUI();
        //只有程序在运行的时候
        if (Application.isPlaying)
        {
#region 第一行
            mapMaker = MapMaker.Instance;
            //开始水平
            EditorGUILayout.BeginHorizontal();
            //获取操作的文件名
            fileNameList = GetNames(fileList);
            //下拉列表
            int currentIndex = EditorGUILayout.Popup(selectIndex, fileNameList);
            //判断当前索引是否为选择的索引 、当前选择对象是否改变
            if (currentIndex != selectIndex)
            {
                //更改索引
                selectIndex = currentIndex;
                //实例化地图的方法
                mapMaker.InitMap();
                //加载当前选择的 Level 文件
                mapMaker.LoadLevelFile(mapMaker.LoadLevelInfoFile(fileNameList[selectIndex]));
                //读取关卡列表

            }

            if (GUILayout.Button("读取关卡列表"))
            {
                //读取关卡列表
                LoadLevelFiles();
            }

            //结束
            EditorGUILayout.EndHorizontal();

#endregion

#region 第二行
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("恢复地图编辑器默认状态"))
            {
                mapMaker.RecoverTowerPoint();
            }
            if (GUILayout.Button("清楚怪物路点"))
            {
                mapMaker.ClearMonsterPath();
            }
            EditorGUILayout.EndHorizontal();
#endregion
            
#region 第三行
            if (GUILayout.Button("保存当前关卡数据文件"))
            {
                mapMaker.SaveLevelFileByJson();
            }

#endregion
        }

    }

    //加载关卡数据
    private void LoadLevelFiles()
    {
        ClearList();
        //加载文件列表、关卡数据
        fileList = GetLevelFiles();
    }

    //清楚文件列表
    private void ClearList()
    {
        fileList.Clear();
        selectIndex = -1;
    }

    //获取当前关卡列表
    private List<FileInfo> GetLevelFiles()
    {
        //获取文件
        string[] files = Directory.GetFiles(Application.dataPath + "/Resources/Json/Level/","*.json");
        List<FileInfo> list = new List<FileInfo>();
        //遍历对象
        for (int i = 0; i < files.Length; i++)
        {
            FileInfo file = new FileInfo(files[i]);
            //对象添加进列表
            list.Add(file);
        }
        return list;
    }
    
    //获取关卡文件的名字
    private string[] GetNames(List<FileInfo> files)
    {
        List<string> names = new List<string>();
        //遍历传递的列表
        foreach (FileInfo file in files)
        {
            names.Add(file.Name);
        }
        return names.ToArray();

    }
}

#endif

//==========================
// - FileName:      GridPoint.cs         
// - Created:       true.	
// - CreateTime:    2020/03/16 17:03:43	
// - Email:         1670328571@qq.com
// - Region:        China WUHAN	
// - Description:   信息存储、交互
//==========================
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
using UnityEngine.EventSystems;

public class GridPoint : MonoBehaviour
{
    //渲染处理（属性）
    private SpriteRenderer spriteRenderer;
    //格子的图片
    private Sprite gridSprite;
    public GridState gridState;
    public GridIndex gridIndex;
    //格子状态（没有建塔的时候建塔、有塔的时候升级塔）
    public bool hasTower;
    //当前格子道具、开始精灵图片
    private Sprite startSprite;
    //不可建塔
    private Sprite coutBuildSprite;
    //引用
    private GameControl gameControl;
    //当前关卡建塔列表
    private GameObject towerListGo;
    //有塔的按钮画布
    private GameObject handleTowerCanvasGo;
    //两个按钮的引用
    private Transform upLevelBtnTrans;
    private Transform sellTowerBtnTrans;
    //按钮的初始位置
    private Vector3 upLevelBtnInitPos;
    private Vector3 sellTowerBtnInitPos;

#if Tool
    //怪物路点图片
    private Sprite monsterPathSprite;
    //所有道具
    public GameObject[] itemPrefabs;
    public GameObject currentItem;
#endif


    [SerializeField]
    //类信息（格子状态）
    public struct GridState
    {
        //是否可以建塔    
        public bool canBuild;
        //是否是怪物路点
        public bool isMonsterPoint;
        //是否有道具
        public bool hasItem;
        //道具 ID
        public int itemID;
    }

    [SerializeField]
    //格子索引（格子的点）
    public struct GridIndex
    {
        public int xIndex;
        public int yIndex;
    }

    private void Awake()
    {
#if Tool
        //获取格子
        gridSprite = Resources.Load<Sprite>("Pictures/NormalMordel/Game/Grid");
        //怪物路点
        monsterPathSprite = Resources.Load<Sprite>("Pictures/NormalMordel/Game/1/Monster/6-1");
        itemPrefabs = new GameObject[10];
        //大关卡索引路径
        string PrefabsPath = "Prefabs/Game/" + MapMaker.Instance.bigLevelID.ToString() + "/Item/";
        for (int i = 0; i < itemPrefabs.Length; i++)
        {
            //加载的游戏物体存储进数组
            itemPrefabs[i] = Resources.Load<GameObject>(PrefabsPath + i);
            //是否加载完成、如果没有该路径
            if (!itemPrefabs[i])
            {
                Debug.Log("加载失败、失败路径" + PrefabsPath + i);
            }
        }
#endif
        spriteRenderer = GetComponent<SpriteRenderer>();
        //初始化格子状态
        InitGrid();
#if Game
        gameControl = GameControl.Instance;
        //格子资源
        gridSprite = gameControl.GetSprite("NormalMordel/Game/Grid");
        startSprite = gameControl.GetSprite("NormalMordel/Game/StartSprite");
        coutBuildSprite = gameControl.GetSprite("NormalMordel/Game/cantBuild");
        //初始化
        spriteRenderer.sprite = startSprite;
        //动画播放
        Tween t = DOTween.To(() => spriteRenderer.color, tocolor => spriteRenderer.color = tocolor, new Color(1, 1, 1, 0.2f), 3f);
        //回调函数动画
        t.OnComplete(ChangeSpriteToGrid);
        towerListGo = gameControl.towerListGo;
        handleTowerCanvasGo = gameControl.handleTowerCanvasGo;
        upLevelBtnTrans = handleTowerCanvasGo.transform.Find("Btn_UpLevel");
        sellTowerBtnTrans = handleTowerCanvasGo.transform.Find("Btn_SellTower");
        upLevelBtnInitPos = upLevelBtnTrans.localPosition;
        sellTowerBtnInitPos = sellTowerBtnTrans.localPosition;
#endif
    }

    //还原样式
    private void ChangeSpriteToGrid()
    {
        //关闭渲染
        spriteRenderer.enabled = false;
        spriteRenderer.color = new Color(1, 1, 1, 1);
        //可以建塔
        if (gridState.canBuild)
        {
            spriteRenderer.sprite = gridSprite;
        }
        else
        {
            //不可建塔
            spriteRenderer.sprite = coutBuildSprite;
        }
    }

    //初始化方法
    public void InitGrid()
    {
        gridState.canBuild = true;
        gridState.isMonsterPoint = false;
        gridState.hasItem = false;
        spriteRenderer.enabled = true;
        gridState.itemID = -1;
#if Tool
        //更改图片
        spriteRenderer.sprite = gridSprite;
        //销毁道具
        Destroy(currentItem);
#endif

    }

#if Game
    //更新格子状态
    public void UpdateGrid()
    {
        //可以建塔
        if (gridState.canBuild)
        {
            spriteRenderer.enabled = true;
            //有道具 的时候
            if (gridState.hasItem)
            {
                CreateItem();
            }
        }
        else
        {
            spriteRenderer.enabled = false;
        }
    }

    //创建物品
    private void CreateItem()
    {
        //加载道具
        GameObject itemGo = GameControl.Instance.GetGameObjectResource(GameControl.Instance.mapMaker.bigLevelID.ToString() + "/Item/" + gridState.itemID);
        itemGo.transform.SetParent(GameControl.Instance.transform);
        //偏移
        Vector3 createPos = transform.position - new Vector3(0, 0, 3);
        if (gridState.itemID <= 2)
        {
            //自身加上偏移
            createPos += new Vector3(GameControl.Instance.mapMaker.gridWidth, -GameControl.Instance.mapMaker.gridHeight) / 2;
        }
        else if (gridState.itemID <= 4)
        {
            createPos += new Vector3(GameControl.Instance.mapMaker.gridWidth, 0) / 2;
        }
        itemGo.transform.position = createPos;
        itemGo.GetComponent<Item>().gridPoint = this;
    }

    private void OnMouseDown()
    {
        //        //选中的时候为 UI return
        //#pragma warning disable CS0472 // 由于此类型的值永不等于 "null"，该表达式的结果始终相同
        //        if (EventSystem.current.IsPointerOverGameObject() == null)
        //#pragma warning restore CS0472 // 由于此类型的值永不等于 "null"，该表达式的结果始终相同
        //        {
        //            return;
        //        }
        Debug.Log("鼠标点击事件");
        gameControl.HandleGrid(this);
    }

    //建完塔之后的处理方法
    public void AfterBuild()
    {
        spriteRenderer.enabled = false;
        //塔的后续处理
        Debug.Log("隐藏");
    }

    //显示格子
    public void ShowGird()
    {
        //当前有无塔
        if (!hasTower)
        {
            spriteRenderer.enabled = true;
            //显示建塔列表
            towerListGo.transform.position = CorrectTowerListGoPosition();
            towerListGo.SetActive(true);
        }
        else
        {
            handleTowerCanvasGo.transform.position = transform.position;
            
            CorrectHandleTowerCanvasGoPosition();
            handleTowerCanvasGo.SetActive(true);
            //显示攻击范围
            //TODO

        }
    }

    //隐藏上一个格子
    public void HideGrid()
    {
        //没有塔的时候
        if (!hasTower)
        {
            //隐藏建塔列表
            towerListGo.SetActive(false);
        }
        else
        {
            //有塔
            handleTowerCanvasGo.SetActive(false);
            //显示塔的范围

        }
        spriteRenderer.enabled = false;
    }

    //不可建塔
    public void ShowCantBuild()
    {
        spriteRenderer.enabled = true;
        Tween t = DOTween.To(() => spriteRenderer.color, tocolor => spriteRenderer.color = tocolor, new Color(1, 1, 1, 0), 2f);
        t.OnComplete
        (() =>
            {
                //关闭渲染
                spriteRenderer.enabled = false;
                //初始化
                spriteRenderer.color = new Color(1, 1, 1, 1);
            }
        );
    }

    //纠正建塔列表位置
    private Vector3 CorrectTowerListGoPosition()
    {
        Vector3 createPositon = Vector3.zero;
        //左边缘
        if (gridIndex.xIndex <= 3 && gridIndex.xIndex >= 0)
        {
            createPositon += new Vector3(gameControl.mapMaker.gridWidth, 0, 0);
        }
        else if (gridIndex.xIndex <= 11 && gridIndex.xIndex >= 8)
        {
            createPositon -= new Vector3(gameControl.mapMaker.gridWidth, 0, 0);
        }
        if (gridIndex.yIndex <= 3 && gridIndex.yIndex >= 0)
        {
            createPositon += new Vector3(0, gameControl.mapMaker.gridHeight, 0);
        }
        else if (gridIndex.yIndex <= 7 && gridIndex.yIndex >= 4)
        {
            createPositon -= new Vector3(0, gameControl.mapMaker.gridHeight, 0);
        }
        createPositon += transform.position;
        return createPositon;
    }

    //纠正画布
    private void CorrectHandleTowerCanvasGoPosition()
    {
        //初始化位置
        upLevelBtnTrans.localPosition = Vector3.zero;
        sellTowerBtnTrans.localPosition = Vector3.zero;
        if (gridIndex.yIndex <= 0)
        {
            //当前塔在最左边
            if (gridIndex.xIndex == 0)
            {
                //偏移
                sellTowerBtnTrans.position += new Vector3(gameControl.mapMaker.gridWidth * 3 / 4, 0, 0);
            }
            else
            {
                sellTowerBtnTrans.position -= new Vector3(gameControl.mapMaker.gridWidth * 3 / 4, 0, 0);
            }
            //升级按钮处理
            upLevelBtnTrans.localPosition = upLevelBtnInitPos;
        }
        else if (gridIndex.yIndex >= 6) 
        {
            if (gridIndex.xIndex == 0)
            {
                upLevelBtnTrans.position += new Vector3(gameControl.mapMaker.gridWidth * 3 / 4, 0, 0);
            }
            else
            {
                upLevelBtnTrans.position -= new Vector3(gameControl.mapMaker.gridWidth * 3 / 4, 0, 0);
            }
            sellTowerBtnTrans.localPosition = sellTowerBtnInitPos;
        }
        else
        {
            upLevelBtnTrans.localPosition = upLevelBtnInitPos;
            sellTowerBtnTrans.localPosition = sellTowerBtnInitPos;
        }
    }

#endif

#if Tool
    //怪物路点
    private void OnMouseDown()
    {
        //玩家按左键的时候 、 怪物路点
        if (Input.GetKey(KeyCode.P))
        {
            //不能建塔
            gridState.canBuild = false;
            //打开渲染
            spriteRenderer.enabled = true;
            //回调、取非
            gridState.isMonsterPoint = !gridState.isMonsterPoint; 
            //是怪物路点的时候
            if (gridState.isMonsterPoint)
            {
                MapMaker.Instance.monsterPath.Add(gridIndex);
                //控制渲染
                spriteRenderer.sprite = monsterPathSprite;
            }
            else
            {
                //不是怪物路点的时候、删除列表
                MapMaker.Instance.monsterPath.Remove(gridIndex);
                //改变格子渲染
                spriteRenderer.sprite = gridSprite;
                //可以建塔
                gridState.canBuild = true;
            }
        }
        else if(Input.GetKey(KeyCode.I))
        {
            //道具
            gridState.itemID++;
            //超出索引、当前格子从持有道具转换为没有道具
            if (gridState.itemID == itemPrefabs.Length)
            {
                gridState.itemID = -1;
                Destroy(currentItem);
                //是否持有道具
                gridState.hasItem = false;
                return;
            }
            if (currentItem == null)
            {
                //产生道具
                CreateItem();
            }
            else
            {
                //本身挂载有道具
                Destroy(currentItem);
                //产生道具的方法
                CreateItem();
            }
            gridState.hasItem = true;
        }
        else if (!gridState.isMonsterPoint)
        {
            //没有键盘操作的时候且不是怪物路点
            gridState.isMonsterPoint = false;
            //取非
            gridState.canBuild = !gridState.canBuild;
            if (gridState.canBuild)
            {
                spriteRenderer.enabled= true;
            }
            else
            {
                spriteRenderer.enabled = false;
            }
        }
    }


    //生成道具的方法
    private void CreateItem()
    {
        Vector3 createPos = transform.position;
        if (gridState.itemID <= 2)
        {
            createPos += new Vector3(MapMaker.Instance.gridWidth, -MapMaker.Instance.gridHeight) / 2;
        }
        else if (gridState.itemID <= 4)
        {
            createPos += new Vector3(MapMaker.Instance.gridWidth,0) / 2;
        }
        GameObject itemGo = Instantiate(itemPrefabs[gridState.itemID], createPos, Quaternion.identity);
        currentItem = itemGo;
    }

    //更新格子状态
    public void UpdateGrid()
    {
        //判断格子状态能否尖塔
        if (gridState.canBuild)
        {
            spriteRenderer.sprite = gridSprite;
            //渲染打开
            spriteRenderer.enabled = true;
            //是否是道具
            if (gridState.hasItem)
            {
                CreateItem();
            }
        }
        else
        {
            //格子是否是怪物路店点
            if (gridState.isMonsterPoint)
            {
                spriteRenderer.sprite = monsterPathSprite;
            }
            else
            {
                //当前格子点无法建塔
                spriteRenderer.enabled = false;
            }
        }
    }
#endif

}


    

//==========================
// - FileName:      Level.cs         
// - Created:       true.	
// - CreateTime:    2020/04/09 16:41:52	
// - Email:         1670328571@qq.com		
// - Region:        China WUHAN	
// - Description:   控制任务链叠加、赋值
//==========================
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Level
{
    //当前关卡波次怪物
    public int totalRound;
    //
    public Round[] roundList;
    //当前的 round
    public int currentRound;

    public Level(int roundNum, List<Round.RoundInfo> roundInfoList)
    {
        totalRound = roundNum;
        roundList = new Round[totalRound];
        //具体内容、
        for (int i = 0; i < totalRound; i++)
        {
            roundList[i] = new Round(roundInfoList[i].mMonsterIDList, i, this);
        }
        //设置任务链
        for (int i = 0; i < totalRound; i++)
        {
            //是否为最后一个元素
            if (i == totalRound - 1)
            {
                break;
            }
            //设置任务
            roundList[i].SetNextRound(roundList[i + 1]);
        }
    }

    //控制者
    public void HandleRound()
    {
        //当前回合大于等于 最后一关
        if (currentRound >= totalRound)
        {
            //游戏胜利

        }
        else if (currentRound == totalRound-1)
        {
            //最后一波怪 的 UI 、音乐

        }
        else
        {
            //普通波次
            roundList[currentRound].Handle(currentRound);
        }
    }

    //调用最后一回合的 Handle 方法
    public void HandleLastRound()
    {
        roundList[currentRound].Handle(currentRound);
    }

    //
    public void AddRoundNum()
    {
        currentRound++;
    }
}

//==========================
// - FileName:      LevelInfo.cs         
// - Created:       true.	
// - CreateTime:    2020/04/06 17:54:32	
// - Email:         1670328571@qq.com		
// - Region:        China WUHAN	
// - Description:   
//==========================
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class LevelInfo
{
    //需要存储的信息

    //大关卡 ID
    public int bigLevelID;
    //小关卡 ID
    public int levelID;
    //所有格子状态、避免使用二维数组
    public List<GridPoint.GridState> gridPoints;
    //怪物路径点、使用索引存储
    public List<GridPoint.GridIndex> monsterPath;
    //当前关卡信息
    public List<Round.RoundInfo> roundInfo;
}


//==========================
// - FileName:      MapMaker.cs         
// - Created:       true.	
// - CreateTime:    2020/03/16 14:27:09	
// - Email:         1670328571@qq.com		
// - Region:        China WUHAN	
// - Description:   地图编辑器工具、游戏中作为地图产生工具
//==========================
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using LitJson;
using System.IO;

public class MapMaker : MonoBehaviour
{

#if Tool
    //开关属性、画线开关
    public bool drawLine;
    //塔的添加点
    public GameObject gridGo;
    
    //在游戏中不是单例、在工具中才是单例
    private static MapMaker _instance;
    public static MapMaker Instance
    {
        get
        {
            return _instance;
        }
    }
#endif
    //地图宽
    private float mapWidth;
    //高
    private float mapHeight;
    [HideInInspector]
    //格子宽
    public float gridWidth;
    [HideInInspector]
    //格子高
    public float gridHeight;
    [HideInInspector]
    //当前关数索引
    public int bigLevelID;
    [HideInInspector]
    public int LevelID;
    //地图的全部格子对象
    public GridPoint[,] gridPoints;
    //行数
    public const int yRow = 8; 
    //列数
    public const int xColumn = 12;

    [HideInInspector]
    //怪物路径点具体位置
    public List<Vector3> monsterPathPos;
    //背景渲染
    private SpriteRenderer bgSR;
    //地图的加载渲染
    private SpriteRenderer roadSR;

    [HideInInspector]
    //怪物路径点、格子索引
    public List<GridPoint.GridIndex> monsterPath;
    //每一波次产生的怪物ID列表
    public List<Round.RoundInfo> roundInfoList;

    [HideInInspector]
    public Carrot carrot;

    private void Awake()
    {
#if Tool
        _instance = this;
        //InitMapMaker();
#endif
    }

    //初始化地图
    public void InitMapMaker()
    {
        CalculateSize();
        //实例化数组
        gridPoints = new GridPoint[xColumn, yRow];
        monsterPath = new List<GridPoint.GridIndex>();
        //生成格子
        for (int x = 0; x < xColumn; x++)
        {
            for (int y = 0; y < yRow; y++)
            {
#if Tool
                //生成格子对象
                GameObject itemGo = Instantiate(gridGo, transform.position, transform.rotation);
#endif
#if Game
                GameObject itemGo = GameControl.Instance.GetGameObjectResource("Grid");
#endif
                //设置属性
                itemGo.transform.position = CorretPositon(x * gridWidth, y * gridHeight);
                itemGo.transform.SetParent(transform);
                //获取格子点
                gridPoints[x, y] = itemGo.GetComponent<GridPoint>();
                gridPoints[x, y].gridIndex.xIndex = x;
                gridPoints[x, y].gridIndex.xIndex = y;
            }
        }
        //获取渲染组件
        bgSR = transform.Find("BG").GetComponent<SpriteRenderer>();
        roadSR = transform.Find("Road").GetComponent<SpriteRenderer>();
    }

    //加载地图
#if Game
    public void LoadMap(int bigLevel,int Level)
    {
        bigLevelID = bigLevel;
        LevelID = Level;
        //加载文件
        LoadLevelFile(LoadLevelInfoFile("Level" + bigLevelID.ToString() + "_" + LevelID.ToString() + ".json"));
        monsterPathPos = new List<Vector3>();
        //遍历怪物路径列表
        for (int i = 0; i < monsterPath.Count; i++)
        {
            //位置添加进列表
            monsterPathPos.Add(gridPoints[monsterPath[i].xIndex,monsterPath[i].yIndex].transform.position); 
        }
        //起始点与终止点
        GameObject startPointGo = GameControl.Instance.GetGameObjectResource("startPoint");
        //怪物点的第一个位置
        startPointGo.transform.position = monsterPathPos[0];
        startPointGo.transform.SetParent(transform);
        GameObject endPointGo = GameControl.Instance.GetGameObjectResource("Carrot");
        //怪物点的第一个位置
        endPointGo.transform.position = monsterPathPos[monsterPathPos.Count - 1];
        endPointGo.transform.SetParent(transform);
        carrot = endPointGo.GetComponent<Carrot>();
    }
#endif


    //纠正预制件的起始位置
    public Vector3 CorretPositon(float x,float y)
    {
        return new Vector3(x - mapWidth / 2 + gridWidth / 2, y- mapHeight / 2 + gridHeight / 2);
    }


    //计算地图格子的宽高
    private void CalculateSize()
    {
        //左下角
        Vector3 leftDown = new Vector3(0, 0);
        //右上角
        Vector3 rightUp = new Vector3(1, 1);
        //视口坐标转世界坐标 、 左下角的世界坐标
        Vector3 posOne = Camera.main.ViewportToWorldPoint(leftDown);
        //右上角
        Vector3 posTwo = Camera.main.ViewportToWorldPoint(rightUp);
        //地图宽
        mapWidth = posTwo.x - posOne.x;
        //地图高
        mapHeight = posTwo.y - posOne.y;
        //格子的宽
        gridWidth = mapWidth / xColumn;
        //格子高
        gridHeight = mapHeight / yRow;
    }

#if Tool
    //画格子
    private void OnDrawGizmos()
    {
        //画线
        if (drawLine)
        {
            //计算格子的大小
            CalculateSize();
            //格子的颜色
            Gizmos.color = Color.green;
            //画出行数   这里的值应该是要等于行数的
            for (int y = 0; y <= yRow; y++)
            {
                //起始位置
                Vector3 startPos = new Vector3(-mapWidth / 2, -mapHeight / 2 + y * gridHeight);
                //终点坐标
                Vector3 endPos = new Vector3(mapWidth / 2, -mapHeight / 2 + y * gridHeight);
                //画线
                Gizmos.DrawLine(startPos, endPos);
            }
            //画列
            for (int x = 0; x <= xColumn; x++)
            {
                Vector3 startPos = new Vector3(-mapWidth / 2 + gridWidth * x, mapHeight / 2);
                Vector3 endPos = new Vector3(-mapWidth / 2 + x * gridWidth, -mapHeight / 2);
                Gizmos.DrawLine(startPos, endPos);
            }
        }
        else
        {
            return;
        }
    }
#endif
    //清除怪物路点
    public void ClearMonsterPath()
    {
        monsterPath.Clear();
    }

    //恢复地图编辑默认状态
    public void RecoverTowerPoint()
    {
        //清除怪物路点
        ClearMonsterPath();
        for (int x = 0; x < xColumn; x++)
        {
            for (int y = 0; y < yRow; y++)
            {
                //初始化塔点
                gridPoints[x, y].InitGrid();
            }
        }
    }

    //初始化地图
    public void InitMap()
    {
        //大小关卡 ID 置0 
        bigLevelID = 0;
        LevelID = 0;
        RecoverTowerPoint();
        //清除怪物路经
        roundInfoList.Clear();
        //渲染清除
        bgSR.sprite = null;
        roadSR.sprite = null;
    }

#if Tool
    //生成 LevelInfo 对象，保存文件
    private LevelInfo CreateLevelInfoGo()
    {
        LevelInfo levelInfo = new LevelInfo()
        {
            bigLevelID = this.bigLevelID,
            levelID = this.LevelID,
        };
        levelInfo.gridPoints = new List<GridPoint.GridState>();
        //遍历
        for (int x = 0; x < xColumn; x++)
        {
            for (int y = 0; y < yRow; y++)
            {
                //添加进信息对象列表
                levelInfo.gridPoints.Add(gridPoints[x, y].gridState);
            }
        }
        levelInfo.monsterPath = new List<GridPoint.GridIndex>();
        //遍历怪物路径
        for (int i = 0; i < monsterPath.Count; i++)
        {
            levelInfo.monsterPath.Add(monsterPath[i]);
        }
        //产生怪物的 ID 列表
        levelInfo.roundInfo = new List<Round.RoundInfo>();
        for (int i = 0; i < roundInfoList.Count; i++)
        {
            levelInfo.roundInfo.Add(roundInfoList[i]);
        }
        Debug.Log("保存成功");
        return levelInfo;
    }
    
    //保存成 Json、保存当前关卡
    public void SaveLevelFileByJson()
    {
        LevelInfo levelInfoGo = CreateLevelInfoGo();
        //路径
        string filePath = Application.dataPath + "/Resources/Json/Level/" + bigLevelID.ToString() + "_" + LevelID.ToString() + ".json";
        //对象转换字符串
        string saveJsonStr = JsonMapper.ToJson(levelInfoGo);  
        //文件流
        StreamWriter sw = new StreamWriter(filePath);
        //写的内容  
        sw.Write(saveJsonStr);
        //关闭文件流
        sw.Close();
    }
#endif

    //读取关卡文件、解析Josn 转换为对象
    public LevelInfo LoadLevelInfoFile(string fileName)
    {
        LevelInfo levelInfo = new LevelInfo(); 
        //完善路径
        string filePath = Application.dataPath + "/Resources/Json/Level/" + fileName;
        //文件读取流、判断路径是否存在
        if (File.Exists(filePath))
        {
            //如果存在
            StreamReader sr = new StreamReader(filePath);
            //读成字符串
            string jsonStr = sr.ReadToEnd();
            //关闭文件流
            sr.Close();
            //取得对象
            levelInfo = JsonMapper.ToObject<LevelInfo>(jsonStr);
            return levelInfo;
        }
        Debug.Log("文件加载失败、失败路径"+filePath);
        return null;
    }

    //信息转换
    public void LoadLevelFile(LevelInfo levelInfo)
    {
        bigLevelID = levelInfo.bigLevelID;
        LevelID = levelInfo.levelID;
        for (int x = 0; x < xColumn; x++)
        {
            for (int y = 0; y < yRow; y++)
            {
                //更新信息
                gridPoints[x, y].gridState = levelInfo.gridPoints[y + x * yRow];
                //更新格子状态
                gridPoints[x, y].UpdateGrid();
            }
        }
        //清除
        monsterPath.Clear();
        //怪物路径
        for (int i = 0; i < levelInfo.monsterPath.Count; i++)
        {
            monsterPath.Add(levelInfo.monsterPath[i]);
        }
        roundInfoList = new List<Round.RoundInfo>();
        for (int i = 0; i < levelInfo.roundInfo.Count; i++)
        {
            roundInfoList.Add(levelInfo.roundInfo[i]);
        }
        //设置地图的图片切换
        bgSR.sprite = Resources.Load<Sprite>("Pictures/NormalMordel/Game/" + bigLevelID.ToString() + "/" + "BG" + (LevelID / 3).ToString());
        roadSR.sprite = Resources.Load<Sprite>("Pictures/NormalMordel/Game/" + bigLevelID.ToString() + "/" + "Road" + LevelID);

    }
    
}

//==========================
// - FileName:      Round.cs         
// - Created:       true.	
// - CreateTime:    2020/04/06 17:24:47	
// - Email:         1670328571@qq.com		
// - Region:        China WUHAN	
// - Description:   
//==========================
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;

public class Round
{
    [Serializable]
    //存储信息 
    public struct RoundInfo
    {
        //怪物列表信息
        public int[] mMonsterIDList;
    }
    
    //对象
    public RoundInfo roundInfo;
    //下一个对象
    protected Round mNextRound;
    //当前关卡的编号
    protected int mRoundID;
    //Level 对象
    protected Level mlevel;

    public Round(int[] monsterIDList, int roundID, Level level)
    {
        mlevel = level;
        roundInfo.mMonsterIDList = monsterIDList;
        mRoundID = roundID;
    }

    //下一个任务链
    public void SetNextRound(Round nextRound)
    {
        mNextRound = nextRound;
    }

    //责任链的判定
    public void Handle(int roundID)
    {
        //如果当前回合并不是理想中 的 ID
        if (mRoundID < roundID)
        {
            mNextRound.Handle(roundID);
        }
        else
        {
            //当前任务链大于等于 ID 、产生怪物
            GameControl.Instance.mMonsterIDList = roundInfo.mMonsterIDList;
            GameControl.Instance.CreateMonster();
            
        }
    }

}


//==========================
// - FileName:      Stage.cs         
// - Created:       true.	
// - CreateTime:    2020/03/11 19:05:34	
// - Email:         1670328571@qq.com		
// - Region:        China WUHAN	
// - Description:   存储所有的关卡信息
//==========================
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Stage
{
    //
    public int[] mTowerIDList;
    //具体长度
    public int mTowerIDListLength;
    //当前关卡是否清除所有道具
    public bool mAllClear;
    //萝卜状态
    public int mCarrotState;
    //小关卡ID 
    public int mLevelID;
    //大关卡ID
    public int mBigLevelID;
    //当前关卡是否解锁
    public bool unLocked;
    //当前关卡是否为奖励、隐藏关卡
    public bool mIsRewardLevel;
    //当前怪物波数
    public int mTotalRound;


    //使用构造进行赋值
    public Stage(int totalRound, int towerIDListLength, int[] towerIDList,
        bool allClear, int carrotState, int levelID, int bigLevelID, bool locked, bool isRewardLevel)
    {
        mTotalRound = totalRound;
        mTowerIDListLength = towerIDListLength;
        mTowerIDList = towerIDList;
        mAllClear = allClear;
        mCarrotState = carrotState;
        mLevelID = levelID;
        mBigLevelID = bigLevelID;
        unLocked = locked;
        mIsRewardLevel = isRewardLevel;
    }
}
true...
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity 实时更新世界地形插件 Online Maps
03-26
然后，在Unity编辑器中配置地图服务的API密钥和其他参数，以启用在线地图功能。 2. **地图对象的添加与操作**：通过脚本控制，可以动态地添加、移除或修改地图上的标记、路径和区域，实现动态交互。 3. **性能优化...
Unity Mega-Fiers插件
12-22
2. **骨权重编辑器（Bone Weight Editor）**：允许开发者精细调整模型的骨骼权重，使得角色动画更加自然流畅，特别是对于复杂的角色动画和非标准的骨骼结构。 3. **粒子影响器（Particle Affectors）**：通过粒子...
Unity中的CustomEditor(自定义编辑器)
木头圈
10-25 1万+
本文分享Unity中的CustomEditor(自定义编辑器) Unity对继承了MonoBehavior脚本的类(当然还有其它类)提供了属性面板的展示和修改. 默认情况下会显示类的公开字段(public field), 当然这些字段也会被序列化并存储在挂载的预制上. 有些情况下我们需要自定义展示和修改逻辑, 这时我们需要用到CustomEditor. 本文将对CustomEditor做一些基本的介绍, 主要围绕类的可序列化字段展开. CustomEditor的基本知识 下面我们先给出一个相对完整的代码,
三、Unity编辑器开发之CustomEditor
当代野生程序猿
02-26 4281
CustomEditor特性，允许我们自定义组件的Inspect检视面板。 public CustomEditor (Type inspectedType); public CustomEditor (Type inspectedType, bool editorForChildClasses); param1: inspectedType 检视的类型，即自定义哪个类型的Inspector。 param2: editorForChildClasses 默认为false，为true时表明其子类使用同样
Unity编辑器极限改造：从零打造高效神器，解锁游戏开发超能力！
最新发布
码趣阿佑
05-02 1475
解锁Unity编辑器的隐藏潜能，成为游戏开发的魔法大师！这份指南将带你深入编辑器扩展的奇幻世界，从基础到高阶，一步步构建属于你的定制化开发利器。无论是自定义Inspector的魔法改造，还是编辑器菜单的独家定制，你都能信手拈来，让工作效率与创意自由齐飞！
Unity 关于制作一个2D的小地图
jijikok的博客
03-28 2586
3.所以其实就是通过纹理实现小地图，本质上我们小地图其实和地图同时运作，只不过我们的主摄像机不渲染小地图，我们把小地图渲染在纹理上，最后输出在UI里。到这一步，我们已经完整设置了小地图在相机上的显示，（记得调一下相机的优先显示，priority，会决定哪个相机先显示）问题：记得我们是不显示carmer2和mimap的图像的，所以在这里记得把层级设为UI，我们是需要显示的。分别为：角色小地图Icon；小地图摄像机 ，小地图光源，小地图实际摄像机。同时这里说一个问题，在同层级的图片，序列越晚渲染越上层。
unity3d 2019 tilemap 地图编辑
热门推荐
炼丹炉里有煤灰
12-26 1万+
该功能是unity内置的地图编辑。适用于2d游戏的关卡设计 1，新建地图 hierarchy对象窗口-&gt;create-&gt;2d object-&gt;tile map 2，打开笔刷窗口 window-&gt;tile palette 3，新建一个笔刷元素 project-&gt;create-&gt;tile 4,新建sprint project-&gt;create-&gt;sq...
Unity学习笔记--实现一个简单的2D地图编辑器
游戏码农一枚，不定时分享技术文章~
07-17 3811
效果图 步骤一 首先我们新建一个3D的项目（3D和2D都行）。 步骤二 在Assets文件夹下面新建一个Picture文件夹存放我们的图片。 我把我工程的素材发出来。 墙 地面 之后把素材拖入到Picture文件夹下面。 步骤三 在Hierarchy窗口下创建一个Sprite，把我们的图片托上去。之后在Assets文件夹下面新建一个文件夹叫做Prefab，把我们的游戏物体拖进去。 现在我们的Prefab文件夹下面应该有两个预制体了，一个地面一个墙。 步骤四 在Assets文件夹下新建一个Script
Unity游戏源码分享-三国群英传 武将天赋版
07-21
它采用C#作为主要编程语言，结合可视化编辑器，使得游戏开发流程更为高效。在本项目中，源码将展示如何使用Unity构建游戏世界，管理游戏对象，处理用户输入，以及实现复杂的战斗逻辑。 三国群英传是一款以中国历史...
Tiled地图编辑器V0.10.2.rar
09-02
其中，Tiled Map Editor（简称Tiled）是一款备受推崇的开源2D地图编辑器，它的最新版本V0.10.2更是在功能和易用性上进行了显著提升。这个名为"TiledMap 最新地图编辑器安装程序tiled-0.10.2-win32-setup.exe"的文件...
星际地图编辑器（个人版）
11-01
这个编辑器虽然目前不具备存盘功能，但已经实现了两种基础地形风格：泥地和雪地，为用户提供多样化的场景设定。下面将详细探讨这款编辑器涉及的IT知识点。 1. **图形用户界面 (GUI) 设计**： 星际地图编辑器的界面...
Tiled-2D地图编辑器（含Unity插件）
09-22
免费的2D地图编辑器，支持直接导入Unity。中文系统下，软件界面有汉化。 版本：Version 2017.09.13。 适用平台：windows 64位。
游戏开发小结——我在 Unity 中制作了自定义编辑器
小云同志你好的博客
12-28 1446
在开发自己的游戏时，在 Unity 中制作自定义编辑器脚本可以改变游戏规则。根据您的项目需求量身定制的自定义检查器、窗口和工具可提高效率和精度，使开发过程更加顺畅和愉快
【Unity小知识】Editor编写常用方法汇总
Backyard Garden Of Games
03-16 3666
MenuItem("EditorTools/自定义的编辑器方法")]如图一，添加自定义的菜单栏需要使用UnityEditor的命名空间，我们自定义的EditorTools类需要继承EditorWindow类。然后就是定义菜单栏点击后所执行的具体函数CustomEditroFunction，这里需要注意的是函数需要是静态函数，需要增加static关键字。MenuItem方法则是定义菜单栏的路径，菜单栏路径可以采用中文。图二则是自定义菜单栏的效果。
【学习笔记】Unity扩展编辑器【待更新】
一个人心の屋
09-19 200
扩展编辑器，Editor
Unity获取脚本的CustomEditor(自定义编辑)数据
Aili_Xiao的博客
08-17 1507
Unity获取脚本的CustomEditor(自定义编辑)数据 我们要想在编辑器这边获取CustomEditor(自定义编辑)类的序列化数据时，只需要将当前类对象序列化即可。
Unity自定义Editor简明教程
七夜听雪
01-07 2316
Unity Custom Editor Unity中可以通过编写脚本实现自定义的Editor。好用Editor可以使开发事半功倍。 Asset Store上大部分第三方插件如NGUI、PlayMaker等都包含自定义Editor的部分。 自定义Editor主要包含两部分：Editor Window和Custom Editor。 Editor Window 顾名思义就是一个单独窗口的Edito...
【GEngine】Unity脚本框架、Custom Inspector
记性太差
01-06 1508
BaseBehaviour，所有脚本基类，主要是方便统一管理，如打包前向所有BaseBehaviour脚本发送消息，调用打包前事件就可以对所有资源进行预处理。同时与BaseEditorRequire结合，方便在同一脚本内部自定义Inspector面板，并且不用公开属性，用#if Unity_Editor分隔编辑器下代码，也不用担心Realse发布问题。 BaseEditorRequire
Unity（十七）：拓展编辑器 - 重绘脚本面板、添加并自定义预览面板
You瞧谁不起 - 道不尽世间的沧桑，诉不完人生的悲凉
01-15 797
重绘脚本面板 using UnityEditor; using UnityEngine; namespace Scripts_03 { #region 自定义脚本面板 public class ExpandPlane : MonoBehaviour { public enum Sex { a = 1, b } public string str1;
unity 编辑器拓展
09-05
Unity编辑器拓展（Editor Extension）可以通过自定义的脚本来扩展Unity编辑器的功能和界面，以满足特定项目的需求。通过编辑器拓展，开发者可以创建自定义的编辑器窗口、工具栏按钮、菜单项、检视面板等，来增强...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值