许可优化
许可优化
产品
产品
解决方案
解决方案
服务支持
服务支持
关于
关于
软件库
当前位置:服务支持 >  软件文章 >  Unity基于GraphView的可视化关卡编辑器开发指南

Unity基于GraphView的可视化关卡编辑器开发指南

阅读数 16
点赞 0
article_banner


一、技术背景与核心优势

1. GraphView技术架构

GraphView是Unity Editor的节点图编辑框架,基于Unity UI Toolkit构建,提供:

可视化节点编辑:拖拽式节点创建与连接

无限画布:支持大型关卡布局

自定义样式系统:USS样式表控制外观

事件处理机制:完整的用户交互支持

对惹,这里有一个游戏开发交流小组984358500,希望大家可以点击进来一起交流一下开发经验呀

2. 可视化关卡编辑器核心价值

传统方法弊端 GraphView方案优势

场景视图手动摆放 逻辑关系可视化

预制体嵌套复杂 节点化模块管理

难以维护关卡流程 清晰连接关系

缺少宏观视图 缩略图全局概览

二、核心架构设计

三、基础编辑器实现

1. 主编辑器窗口

csharp

using UnityEditor;

using UnityEditor.Experimental.GraphView;

using UnityEngine;

using UnityEngine.UIElements;

public class LevelGraphEditorWindow : EditorWindow

{

private LevelGraphView _graphView;

private string _currentFileName = "New Level";

[MenuItem("Tools/关卡编辑器")]

public static void OpenWindow()

{

var window = GetWindow<LevelGraphEditorWindow>();

window.titleContent = new GUIContent("关卡编辑器");

window.minSize = new Vector2(800, 600);

}

private void OnEnable()

{

ConstructGraphView();

GenerateToolbar();

GenerateMinimap();

LoadStyles();

}

private void ConstructGraphView()

{

_graphView = new LevelGraphView

{

name = "关卡图"

};

_graphView.StretchToParentSize();

rootVisualElement.Add(_graphView);

// 添加网格背景

var grid = new GridBackground();

grid.StretchToParentSize();

_graphView.Insert(0, grid);

}

private void GenerateToolbar()

{

var toolbar = new Toolbar();

// 房间创建按钮

var createRoomBtn = new Button(() => CreateRoomNode("房间"))

{

text = "创建房间",

tooltip = "添加一个新房间节点"

};

toolbar.Add(createRoomBtn);

// 敌人点创建按钮

var createEnemyBtn = new Button(() => CreateEnemyNode("敌人点"))

{

text = "敌人点",

tooltip = "添加敌人出生点"

};

toolbar.Add(createEnemyBtn);

// 保存按钮

var saveBtn = new Button(() => SaveData())

{

text = "保存",

tooltip = "保存当前关卡"

};

toolbar.Add(saveBtn);

// 加载按钮

var loadBtn = new Button(() => LoadData())

{

text = "加载",

tooltip = "加载关卡文件"

};

toolbar.Add(loadBtn);

// 生成场景按钮

var generateBtn = new Button(() => GenerateScene())

{

text = "生成场景",

tooltip = "根据节点图生成Unity场景"

};

toolbar.Add(generateBtn);

rootVisualElement.Add(toolbar);

}

private void GenerateMinimap()

{

var minimap = new MiniMap { anchored = true };

minimap.SetPosition(new Rect(10, 30, 200, 140));

_graphView.Add(minimap);

}

private void LoadStyles()

{

var styleSheet = AssetDatabase.LoadAssetAtPath<StyleSheet>(

"Assets/Editor/LevelGraphStyles.uss");

if (styleSheet != null)

{

rootVisualElement.styleSheets.Add(styleSheet);

}

}

}

2. 自定义GraphView

csharp

using System.Collections.Generic;

using UnityEditor.Experimental.GraphView;

using UnityEngine;

public class LevelGraphView : GraphView

{

public LevelGraphView()

{

// 添加交互控制器

this.AddManipulator(new ContentDragger());

this.AddManipulator(new SelectionDragger());

this.AddManipulator(new RectangleSelector());

this.AddManipulator(new ClickSelector());

// 缩放控制

SetupZoom(ContentZoomer.DefaultMinScale * 0.2f,

ContentZoomer.DefaultMaxScale * 2f);

// 背景样式

style.backgroundColor = new Color(0.1f, 0.1f, 0.1f);

}

// 获取兼容的端口用于连接

public override List<Port> GetCompatiblePorts(Port startPort, NodeAdapter nodeAdapter)

{

var compatiblePorts = new List<Port>();

ports.ForEach((port) =>

{

// 防止自连接

if (startPort == port) return;

// 防止同一节点连接

if (startPort.node == port.node) return;

// 输入只能连接输出

if (startPort.direction == port.direction) return;

// 类型必须匹配

if (startPort.portType != port.portType) return;

compatiblePorts.Add(port);

});

return compatiblePorts;

}

// 创建房间节点

public RoomNode CreateRoomNode(string nodeName, Vector2 position)

{

var roomNode = new RoomNode(nodeName)

{

title = nodeName

};

roomNode.SetPosition(new Rect(position, roomNode.defaultSize));

AddElement(roomNode);

return roomNode;

}

// 创建敌人节点

public EnemyNode CreateEnemyNode(string nodeName, Vector2 position)

{

var enemyNode = new EnemyNode(nodeName)

{

title = nodeName

};

enemyNode.SetPosition(new Rect(position, enemyNode.defaultSize));

AddElement(enemyNode);

return enemyNode;

}

}

四、节点系统实现

1. 基础节点类

csharp

using System;

using UnityEditor.Experimental.GraphView;

using UnityEngine;

using UnityEngine.UIElements;

public abstract class LevelNode : Node

{

public string GUID { get; protected set; }

public Vector2 Position { get; set; }

public NodeType NodeType { get; protected set; }

protected LevelGraphView graphView;

public LevelNode(string nodeName, LevelGraphView graphView = null)

{

GUID = Guid.NewGuid().ToString();

title = nodeName;

this.graphView = graphView;

// 基础样式

style.minWidth = 200;

style.minHeight = 150;

// 添加右键菜单

this.AddManipulator(new ContextualMenuManipulator(BuildContextualMenu));

}

protected virtual void BuildContextualMenu(ContextualMenuPopulateEvent evt)

{

http://evt.menu.AppendAction("删除", (e) => DeleteNode());

http://evt.menu.AppendAction("复制", (e) => DuplicateNode());

http://evt.menu.AppendSeparator();

}

protected virtual void DeleteNode()

{

if (graphView != null)

{

graphView.RemoveElement(this);

}

}

protected abstract void DuplicateNode();

// 序列化节点数据

public virtual NodeData Serialize()

{

return new NodeData

{

Guid = GUID,

NodeType = NodeType.ToString(),

Position = GetPosition().position,

Title = title

};

}

// 反序列化节点数据

public virtual void Deserialize(NodeData data)

{

GUID = data.Guid;

title = data.Title;

SetPosition(new Rect(data.Position, defaultSize));

}

}

public enum NodeType

{

Room,

Enemy,

Item,

Trigger,

Boss

}

2. 房间节点实现

csharp

public class RoomNode : LevelNode

{

public RoomType RoomType { get; set; }

public int EnemyCount { get; set; }

public int ItemCount { get; set; }

public Vector3 RoomSize { get; set; }

private EnumField roomTypeField;

private IntegerField enemyCountField;

private IntegerField itemCountField;

private Vector3Field roomSizeField;

public RoomNode(string nodeName, LevelGraphView graphView = null)

: base(nodeName, graphView)

{

NodeType = http://NodeType.Room;

RoomType = RoomType.Normal;

RoomSize = new Vector3(10, 5, 10);

InitializePorts();

InitializeFields();

SetupStyle();

}

private void InitializePorts()

{

// 输入端口

var inputPort = InstantiatePort(

Orientation.Horizontal,

Direction.Input,

Port.Capacity.Multi,

typeof(bool));

inputPort.portName = "入口";

inputPort.tooltip = "房间的入口连接点";

inputContainer.Add(inputPort);

// 输出端口

var outputPort = InstantiatePort(

Orientation.Horizontal,

Direction.Output,

Port.Capacity.Multi,

typeof(bool));

outputPort.portName = "出口";

outputPort.tooltip = "房间的出口连接点";

outputContainer.Add(outputPort);

}

private void InitializeFields()

{

// 房间类型选择

roomTypeField = new EnumField("房间类型", RoomType);

roomTypeField.RegisterValueChangedCallback(evt =>

{

RoomType = (RoomType)evt.newValue;

UpdateStyleByRoomType();

});

mainContainer.Add(roomTypeField);

// 敌人数目

enemyCountField = new IntegerField("敌人数目")

{

value = 0

};

enemyCountField.RegisterValueChangedCallback(evt =>

{

EnemyCount = evt.newValue;

});

mainContainer.Add(enemyCountField);

// 道具数目

itemCountField = new IntegerField("道具数目")

{

value = 0

};

itemCountField.RegisterValueChangedCallback(evt =>

{

ItemCount = evt.newValue;

});

mainContainer.Add(itemCountField);

// 房间尺寸

roomSizeField = new Vector3Field("房间尺寸")

{

value = RoomSize

};

roomSizeField.RegisterValueChangedCallback(evt =>

{

RoomSize = evt.newValue;

});

mainContainer.Add(roomSizeField);

}

private void SetupStyle()

{

AddToClassList("room-node");

UpdateStyleByRoomType();

}

private void UpdateStyleByRoomType()

{

// 清除现有类型样式

RemoveFromClassList("start-room");

RemoveFromClassList("boss-room");

RemoveFromClassList("treasure-room");

// 添加对应样式

switch (RoomType)

{

case RoomType.Start:

AddToClassList("start-room");

break;

case RoomType.Boss:

AddToClassList("boss-room");

break;

case RoomType.Treasure:

AddToClassList("treasure-room");

break;

}

}

protected override void DuplicateNode()

{

var newNode = graphView?.CreateRoomNode(title + " (副本)",

GetPosition().position + new Vector2(20, 20));

if (newNode != null)

{

newNode.RoomType = RoomType;

newNode.EnemyCount = EnemyCount;

newNode.ItemCount = ItemCount;

newNode.RoomSize = RoomSize;

}

}

public override NodeData Serialize()

{

var data = base.Serialize();

data.AdditionalData = JsonUtility.ToJson(new RoomNodeData

{

RoomType = RoomType,

EnemyCount = EnemyCount,

ItemCount = ItemCount,

RoomSize = RoomSize

});

return data;

}

public override void Deserialize(NodeData data)

{

base.Deserialize(data);

if (!string.IsNullOrEmpty(data.AdditionalData))

{

var roomData = JsonUtility.FromJson<RoomNodeData>(data.AdditionalData);

RoomType = roomData.RoomType;

EnemyCount = roomData.EnemyCount;

ItemCount = roomData.ItemCount;

RoomSize = roomData.RoomSize;

// 更新UI字段

roomTypeField.SetValueWithoutNotify(RoomType);

enemyCountField.SetValueWithoutNotify(EnemyCount);

itemCountField.SetValueWithoutNotify(ItemCount);

roomSizeField.SetValueWithoutNotify(RoomSize);

UpdateStyleByRoomType();

}

}

}

public enum RoomType

{

Normal,

Start,

Boss,

Treasure,

Secret,

Shop

}

3. 敌人节点实现

csharp

public class EnemyNode : LevelNode

{

public EnemyType EnemyType { get; set; }

public int Level { get; set; }

public int Count { get; set; }

private EnumField enemyTypeField;

private IntegerField levelField;

private IntegerField countField;

private ObjectField prefabField;

public EnemyNode(string nodeName, LevelGraphView graphView = null)

: base(nodeName, graphView)

{

NodeType = NodeType.Enemy;

EnemyType = EnemyType.Normal;

Level = 1;

Count = 1;

InitializePorts();

InitializeFields();

SetupStyle();

}

private void InitializePorts()

{

// 敌人节点通常只有一个输入端口

var inputPort = InstantiatePort(

Orientation.Horizontal,

Direction.Input,

Port.Capacity.Single,

typeof(bool));

inputPort.portName = "位置";

inputPort.tooltip = "敌人生成位置";

inputContainer.Add(inputPort);

}

private void InitializeFields()

{

// 敌人类型

enemyTypeField = new EnumField("敌人类型", EnemyType);

enemyTypeField.RegisterValueChangedCallback(evt =>

{

EnemyType = (EnemyType)evt.newValue;

});

mainContainer.Add(enemyTypeField);

// 敌人等级

levelField = new IntegerField("等级")

{

value = Level,

tooltip = "敌人等级(1-10)"

};

levelField.RegisterValueChangedCallback(evt =>

{

Level = Mathf.Clamp(evt.newValue, 1, 10);

});

mainContainer.Add(levelField);

// 敌人数目

countField = new IntegerField("数量")

{

value = Count

};

countField.RegisterValueChangedCallback(evt =>

{

Count = Mathf.Max(1, evt.newValue);

});

mainContainer.Add(countField);

// 预制体引用

prefabField = new ObjectField("敌人预制体")

{

objectType = typeof(GameObject),

tooltip = "敌人的预制体资源"

};

mainContainer.Add(prefabField);

}

private void SetupStyle()

{

AddToClassList("enemy-node");

}

protected override void DuplicateNode()

{

var newNode = graphView?.CreateEnemyNode(title + " (副本)",

GetPosition().position + new Vector2(20, 20));

if (newNode != null)

{

newNode.EnemyType = EnemyType;

newNode.Level = Level;

newNode.Count = Count;

newNode.prefabField.value = prefabField.value;

}

}

}

public enum EnemyType

{

Normal,

Elite,

Boss,

Ranged,

Melee,

Flying

}

五、数据持久化系统

1. 序列化数据结构

csharp

using System;

using System.Collections.Generic;

using UnityEngine;

[Serializable]

public class NodeData

{

public string Guid;

public string NodeType;

public Vector2 Position;

public string Title;

public string AdditionalData; // JSON格式的额外数据

}

[Serializable]

public class EdgeData

{

public string InputNodeGuid;

public string OutputNodeGuid;

public string InputPortName;

public string OutputPortName;

}

[Serializable]

public class LevelGraphData

{

public string LevelName;

public List<NodeData> Nodes = new List<NodeData>();

public List<EdgeData> Edges = new List<EdgeData>();

public DateTime LastModified;

// 房间节点特定数据

[Serializable]

public class RoomNodeData

{

public RoomType RoomType;

public int EnemyCount;

public int ItemCount;

public Vector3 RoomSize;

}

// 敌人节点特定数据

[Serializable]

public class EnemyNodeData

{

public EnemyType EnemyType;

public int Level;

public int Count;

public string PrefabPath;

}

}

2. 保存与加载管理器

csharp

using http://System.IO;

using UnityEditor;

using UnityEngine;

public class LevelGraphSaveUtility

{

private LevelGraphView graphView;

private List<Edge> Edges => graphView.edges.ToList();

private List<LevelNode> Nodes => graphView.nodes.ToList()

.Cast<LevelNode>().ToList();

public static LevelGraphSaveUtility GetInstance(LevelGraphView graphView)

{

return new LevelGraphSaveUtility

{

graphView = graphView

};

}

public void SaveGraph(string fileName)

{

if (string.IsNullOrEmpty(fileName))

{

EditorUtility.DisplayDialog("保存失败", "请输入文件名", "确定");

return;

}

var saveData = new LevelGraphData

{

LevelName = fileName,

LastModified = http://DateTime.Now

};

// 保存所有节点

foreach (var node in Nodes)

{

saveData.Nodes.Add(node.Serialize());

}

// 保存所有连接

foreach (var edge in Edges)

{

var inputNode = edge.input.node as LevelNode;

var outputNode = edge.output.node as LevelNode;

if (inputNode != null && outputNode != null)

{

saveData.Edges.Add(new EdgeData

{

InputNodeGuid = inputNode.GUID,

OutputNodeGuid = outputNode.GUID,

InputPortName = edge.input.portName,

OutputPortName = edge.output.portName

});

}

}

// 序列化为JSON

string json = JsonUtility.ToJson(saveData, true);

// 保存到文件

string folderPath = "Assets/LevelData/";

if (!Directory.Exists(folderPath))

{

Directory.CreateDirectory(folderPath);

}

string filePath = folderPath + fileName + ".level";

File.WriteAllText(filePath, json);

AssetDatabase.Refresh();

Debug.Log($"关卡已保存: {filePath}");

}

public void LoadGraph(string fileName)

{

string filePath = "Assets/LevelData/" + fileName + ".level";

if (!File.Exists(filePath))

{

EditorUtility.DisplayDialog("加载失败",

$"文件不存在: {filePath}", "确定");

return;

}

// 读取文件

string json = File.ReadAllText(filePath);

var loadData = JsonUtility.FromJson<LevelGraphData>(json);

// 清空当前视图

ClearGraph();

// 重建节点

var nodeMap = new Dictionary<string, LevelNode>();

foreach (var nodeData in loadData.Nodes)

{

LevelNode node = CreateNodeFromType(nodeData.NodeType, nodeData.Title);

if (node != null)

{

node.Deserialize(nodeData);

nodeMap.Add(nodeData.Guid, node);

graphView.AddElement(node);

}

}

// 重建连接

foreach (var edgeData in loadData.Edges)

{

if (nodeMap.TryGetValue(edgeData.InputNodeGuid, out var inputNode) &&

nodeMap.TryGetValue(edgeData.OutputNodeGuid, out var outputNode))

{

// 查找对应的端口

Port inputPort = FindPort(inputNode, edgeData.InputPortName, Direction.Input);

Port outputPort = FindPort(outputNode, edgeData.OutputPortName, Direction.Output);

if (inputPort != null && outputPort != null)

{

var edge = inputPort.ConnectTo(outputPort);

graphView.AddElement(edge);

}

}

}

Debug.Log($"关卡已加载: {filePath}");

}

private LevelNode CreateNodeFromType(string nodeType, string title)

{

Vector2 center = http://graphView.contentViewContainer.worldBound.center;

return nodeType switch

{

"Room" => graphView.CreateRoomNode(title, center),

"Enemy" => graphView.CreateEnemyNode(title, center),

_ => null

};

}

private Port FindPort(LevelNode node, string portName, Direction direction)

{

var ports = direction == Direction.Input ?

node.inputContainer.Children().OfType<Port>() :

node.outputContainer.Children().OfType<Port>();

return ports.FirstOrDefault(port => port.portName == portName);

}

private void ClearGraph()

{

// 获取所有元素

var nodes = graphView.nodes.ToList();

var edges = graphView.edges.ToList();

// 移除所有连接

foreach (var edge in edges)

{

graphView.RemoveElement(edge);

}

// 移除所有节点

foreach (var node in nodes)

{

graphView.RemoveElement(node);

}

}

}

六、场景生成系统

1. 场景生成器

csharp

using System.Collections.Generic;

using UnityEngine;

public class LevelSceneGenerator

{

public GameObject GenerateScene(LevelGraphData levelData)

{

// 创建关卡根对象

GameObject levelRoot = new GameObject(levelData.LevelName + "_Generated");

// 节点游戏对象映射

var nodeGameObjectMap = new Dictionary<string, GameObject>();

// 生成所有房间

foreach (var nodeData in levelData.Nodes)

{

if (nodeData.NodeType == "Room")

{

GameObject roomObject = GenerateRoom(nodeData);

if (roomObject != null)

{

roomObject.transform.SetParent(levelRoot.transform);

nodeGameObjectMap.Add(nodeData.Guid, roomObject);

}

}

}

// 生成连接路径

foreach (var edgeData in levelData.Edges)

{

if (nodeGameObjectMap.TryGetValue(edgeData.InputNodeGuid, out var startRoom) &&

nodeGameObjectMap.TryGetValue(edgeData.OutputNodeGuid, out var endRoom))

{

GeneratePath(startRoom, endRoom, levelRoot.transform);

}

}

// 生成敌人物品等

GenerateGameObjects(levelData, nodeGameObjectMap, levelRoot.transform);

return levelRoot;

}

private GameObject GenerateRoom(NodeData nodeData)

{

// 解析房间数据

var roomData = JsonUtility.FromJson<LevelGraphData.RoomNodeData>(

nodeData.AdditionalData);

// 创建房间对象

GameObject roomObject = new GameObject(nodeData.Title);

// 添加房间组件

var roomComponent = roomObject.AddComponent<RoomComponent>();

roomComponent.RoomType = roomData.RoomType;

roomComponent.RoomSize = roomData.RoomSize;

// 设置位置(将2D节点位置转换为3D场景位置)

Vector3 position = new Vector3(

nodeData.Position.x,

0,

nodeData.Position.y

);

roomObject.transform.position = position;

// 根据房间类型添加不同外观

GenerateRoomVisual(roomObject, roomData.RoomType, roomData.RoomSize);

return roomObject;

}

private void GenerateRoomVisual(GameObject roomObject, RoomType roomType, Vector3 size)

{

// 创建地面

GameObject floor = GameObject.CreatePrimitive(PrimitiveType.Cube);

http://floor.name = "Floor";

floor.transform.SetParent(roomObject.transform);

floor.transform.localPosition = http://Vector3.zero;

floor.transform.localScale = new Vector3(size.x, 0.1f, size.z);

// 根据房间类型设置材质

Material material = GetRoomMaterial(roomType);

floor.GetComponent<Renderer>().material = material;

// 创建墙壁

CreateWalls(roomObject, size);

}

private Material GetRoomMaterial(RoomType roomType)

{

string materialPath = roomType switch

{

RoomType.Start => "Materials/RoomStart",

RoomType.Boss => "Materials/RoomBoss",

RoomType.Treasure => "Materials/RoomTreasure",

http://RoomType.Shop => "Materials/RoomShop",

_ => "Materials/RoomNormal"

};

return Resources.Load<Material>(materialPath);

}

private void CreateWalls(GameObject roomObject, Vector3 size)

{

float wallHeight = size.y;

float wallThickness = 0.5f;

// 创建四面墙

string[] wallNames = { "NorthWall", "SouthWall", "EastWall", "WestWall" };

Vector3[] positions =

{

new Vector3(0, wallHeight/2, size.z/2),

new Vector3(0, wallHeight/2, -size.z/2),

new Vector3(size.x/2, wallHeight/2, 0),

new Vector3(-size.x/2, wallHeight/2, 0)

};

Vector3[] scales =

{

new Vector3(size.x, wallHeight, wallThickness),

new Vector3(size.x, wallHeight, wallThickness),

new Vector3(wallThickness, wallHeight, size.z),

new Vector3(wallThickness, wallHeight, size.z)

};

for (int i = 0; i < 4; i++)

{

GameObject wall = GameObject.CreatePrimitive(PrimitiveType.Cube);

http://wall.name = wallNames[i];

wall.transform.SetParent(roomObject.transform);

wall.transform.localPosition = positions[i];

wall.transform.localScale = scales[i];

wall.GetComponent<Renderer>().material =

Resources.Load<Material>("Materials/Wall");

}

}

private void GeneratePath(GameObject startRoom, GameObject endRoom, Transform parent)

{

Vector3 startPos = startRoom.transform.position;

Vector3 endPos = endRoom.transform.position;

// 计算路径方向

Vector3 direction = (endPos - startPos).normalized;

float distance = Vector3.Distance(startPos, endPos);

// 创建路径段

GameObject pathSegment = new GameObject("Path");

pathSegment.transform.SetParent(parent);

// 添加路径组件

var pathComponent = pathSegment.AddComponent<PathComponent>();

pathComponent.StartRoom = startRoom;

pathComponent.EndRoom = endRoom;

// 创建路径几何

CreatePathGeometry(pathSegment, startPos, endPos);

}

private void CreatePathGeometry(GameObject pathObject, Vector3 start, Vector3 end)

{

// 创建路径地面

GameObject pathFloor = GameObject.CreatePrimitive(PrimitiveType.Cube);

http://pathFloor.name = "PathFloor";

pathFloor.transform.SetParent(pathObject.transform);

// 计算路径位置和尺寸

Vector3 center = (start + end) / 2;

float length = Vector3.Distance(start, end);

Vector3 scale = new Vector3(3f, 0.1f, length);

pathFloor.transform.position = center;

pathFloor.transform.localScale = scale;

// 旋转以对准方向

Vector3 direction = end - start;

if (direction != http://Vector3.zero)

{

pathFloor.transform.rotation = Quaternion.LookRotation(direction);

}

// 设置路径材质

pathFloor.GetComponent<Renderer>().material =

Resources.Load<Material>("Materials/Path");

}

private void GenerateGameObjects(LevelGraphData levelData,

Dictionary<string, GameObject> nodeMap, Transform parent)

{

foreach (var nodeData in levelData.Nodes)

{

switch (nodeData.NodeType)

{

case "Enemy":

GenerateEnemy(nodeData, nodeMap, parent);

break;

// 可以添加其他类型对象的生成逻辑

}

}

}

private void GenerateEnemy(NodeData nodeData,

Dictionary<string, GameObject> nodeMap, Transform parent)

{

// 解析敌人数据

var enemyData = JsonUtility.FromJson<LevelGraphData.EnemyNodeData>(

nodeData.AdditionalData);

// 查找关联的房间

foreach (var edgeData in nodeData.Edges) // 需要扩展NodeData包含边信息

{

if (nodeMap.TryGetValue(edgeData.InputNodeGuid, out var roomObject))

{

// 在房间内生成敌人

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

{

GameObject enemyPrefab = Resources.Load<GameObject>(enemyData.PrefabPath);

if (enemyPrefab != null)

{

Vector3 roomPos = roomObject.transform.position;

Vector3 randomOffset = new Vector3(

Random.Range(-4, 4),

0,

Random.Range(-4, 4)

);

GameObject enemy = GameObject.Instantiate(

enemyPrefab,

roomPos + randomOffset,

Quaternion.identity,

parent

);

http://enemy.name = $"{nodeData.Title}_{i}";

// 设置敌人属性

var enemyComponent = enemy.GetComponent<EnemyComponent>();

if (enemyComponent != null)

{

enemyComponent.Level = enemyData.Level;

enemyComponent.EnemyType = enemyData.EnemyType;

}

}

}

}

}

}

}

// 辅助组件

public class RoomComponent : MonoBehaviour

{

public RoomType RoomType;

public Vector3 RoomSize;

public List<GameObject> ConnectedRooms = new List<GameObject>();

}

public class PathComponent : MonoBehaviour

{

public GameObject StartRoom;

public GameObject EndRoom;

}

public class EnemyComponent : MonoBehaviour

{

public int Level = 1;

public EnemyType EnemyType = EnemyType.Normal;

}

七、编辑器样式定义

1. USS样式表

css

/* Assets/Editor/LevelGraphStyles.uss */

/* 基础样式 */

#关卡图 {

background-color: rgb(30, 30, 30);

}

/* 节点通用样式 */

.node {

border-width: 2px;

border-radius: 5px;

background-color: rgb(60, 60, 70);

}

.node-title {

color: white;

font-size: 14px;

font-weight: bold;

padding: 8px;

background-color: rgb(80, 80, 90);

border-top-left-radius: 3px;

border-top-right-radius: 3px;

}

/* 房间节点样式 */

.room-node {

border-color: rgb(100, 150, 255);

}

.start-room {

border-color: rgb(100, 255, 100);

background-color: rgba(100, 255, 100, 0.1);

}

.boss-room {

border-color: rgb(255, 100, 100);

background-color: rgba(255, 100, 100, 0.1);

border-width: 3px;

}

.treasure-room {

border-color: rgb(255, 215, 0);

background-color: rgba(255, 215, 0, 0.1);

}

.shop-room {

border-color: rgb(200, 160, 255);

background-color: rgba(200, 160, 255, 0.1);

}

/* 敌人节点样式 */

.enemy-node {

border-color: rgb(255, 100, 100);

background-color: rgba(255, 100, 100, 0.1);

}

/* 端口样式 */

.port {

width: 12px;

height: 12px;

border-radius: 6px;

}

.input-port {

background-color: rgb(100, 200, 100);

}

.output-port {

background-color: rgb(100, 150, 255);

}

/* 连接线样式 */

.edge {

border-color: rgba(150, 150, 255, 0.8);

border-width: 2px;

}

/* 工具栏样式 */

Toolbar {

background-color: rgb(40, 40, 40);

border-bottom-color: rgb(80, 80, 80);

border-bottom-width: 1px;

padding: 4px;

}

Toolbar Button {

margin-left: 4px;

margin-right: 4px;

min-width: 80px;

color: white;

background-color: rgb(70, 70, 80);

border-radius: 3px;

border-width: 0px;

}

Toolbar Button:hover {

background-color: rgb(90, 90, 100);

}

八、高级功能扩展

1. 自动布局系统

csharp

using System.Collections.Generic;

using System.Linq;

using UnityEngine;

public class LevelGraphAutoLayout

{

private LevelGraphView graphView;

private List<LevelNode> nodes;

public void AutoArrange(LevelGraphView graphView)

{

this.graphView = graphView;

this.nodes = graphView.nodes.ToList().Cast<LevelNode>().ToList();

if (nodes.Count == 0) return;

// 找出所有连通分量

var components = FindConnectedComponents();

// 为每个连通分量计算布局

float currentX = 0;

foreach (var component in components)

{

ArrangeComponent(component, currentX);

currentX += GetComponentWidth(component) + 200; // 组件间间距

}

}

private List<List<LevelNode>> FindConnectedComponents()

{

var visited = new HashSet<LevelNode>();

var components = new List<List<LevelNode>>();

foreach (var node in nodes)

{

if (!visited.Contains(node))

{

var component = new List<LevelNode>();

BFS(node, visited, component);

components.Add(component);

}

}

return components;

}

private void BFS(LevelNode start, HashSet<LevelNode> visited, List<LevelNode> component)

{

var queue = new Queue<LevelNode>();

queue.Enqueue(start);

visited.Add(start);

while (queue.Count > 0)

{

var current = queue.Dequeue();

component.Add(current);

// 获取相连的节点

var connectedNodes = GetConnectedNodes(current);

foreach (var neighbor in connectedNodes)

{

if (!visited.Contains(neighbor))

{

visited.Add(neighbor);

queue.Enqueue(neighbor);

}

}

}

}

private List<LevelNode> GetConnectedNodes(LevelNode node)

{

var connected = new List<LevelNode>();

var edges = graphView.edges.ToList();

foreach (var edge in edges)

{

if (edge.input.node == node)

{

connected.Add(edge.output.node as LevelNode);

}

else if (edge.output.node == node)

{

connected.Add(edge.input.node as LevelNode);

}

}

return connected.Where(n => n != null).ToList();

}

private void ArrangeComponent(List<LevelNode> component, float startX)

{

if (component.Count == 0) return;

// 使用简单的层次布局算法

var levels = AssignLevels(component);

float startY = 0;

float levelSpacing = 150;

float nodeSpacing = 120;

foreach (var level in levels)

{

float totalWidth = level.Count 200 + (level.Count - 1) nodeSpacing;

float currentX = startX - totalWidth / 2;

foreach (var node in level)

{

var position = new Rect(currentX, startY, 200, 150);

node.SetPosition(position);

currentX += 200 + nodeSpacing;

}

startY += levelSpacing;

}

}

private List<List<LevelNode>> AssignLevels(List<LevelNode> component)

{

// 简单的BFS分层

var levels = new List<List<LevelNode>>();

var visited = new HashSet<LevelNode>();

var queue = new Queue<(LevelNode, int)>();

// 找到起始节点(没有输入的节点)

var startNodes = component.Where(n =>

!graphView.edges.ToList().Any(e => e.input.node == n)).ToList();

if (startNodes.Count == 0) startNodes.Add(component[0]);

foreach (var start in startNodes)

{

queue.Enqueue((start, 0));

visited.Add(start);

}

while (queue.Count > 0)

{

var (current, level) = queue.Dequeue();

// 确保有足够的层级

while (levels.Count <= level)

{

levels.Add(new List<LevelNode>());

}

if (!levels[level].Contains(current))

{

levels[level].Add(current);

}

// 处理输出节点

var edges = graphView.edges.ToList();

var outputs = edges.Where(e => e.output.node == current)

.Select(e => e.input.node as LevelNode)

.Where(n => n != null && !visited.Contains(n));

foreach (var output in outputs)

{

visited.Add(output);

queue.Enqueue((output, level + 1));

}

}

return levels;

}

private float GetComponentWidth(List<LevelNode> component)

{

// 估算组件宽度

int maxNodesPerLevel = 0;

var levels = AssignLevels(component);

foreach (var level in levels)

{

maxNodesPerLevel = Mathf.Max(maxNodesPerLevel, level.Count);

}

return maxNodesPerLevel 200 + (maxNodesPerLevel - 1) 120;

}

}

2. 实时预览系统

csharp

using UnityEditor;

using UnityEngine;

[InitializeOnLoad]

public class LevelGraphScenePreview

{

private static LevelGraphView currentGraphView;

private static bool showPreview = true;

static LevelGraphScenePreview()

{

SceneView.duringSceneGui += OnSceneGUI;

EditorApplication.playModeStateChanged += OnPlayModeChanged;

}

private static void OnSceneGUI(SceneView sceneView)

{

if (!showPreview || currentGraphView == null) return;

Handles.BeginGUI();

// 获取所有节点

var nodes = currentGraphView.nodes.ToList().Cast<LevelNode>().ToList();

// 绘制节点预览

foreach (var node in nodes)

{

DrawNodePreview(node, sceneView);

}

// 绘制连接预览

var edges = currentGraphView.edges.ToList();

foreach (var edge in edges)

{

DrawEdgePreview(edge, sceneView);

}

Handles.EndGUI();

}

private static void DrawNodePreview(LevelNode node, SceneView sceneView)

{

// 将2D位置转换为3D场景位置

Vector3 worldPosition = new Vector3(

node.GetPosition().position.x,

0,

node.GetPosition().position.y

);

// 计算屏幕位置

Vector3 screenPosition = http://sceneView.camera.WorldToScreenPoint(worldPosition);

// 如果点在摄像机后面,跳过

if (screenPosition.z < 0) return;

// 转换为GUI坐标

screenPosition.y = http://sceneView.camera.pixelHeight - screenPosition.y;

// 根据节点类型设置颜色

Color color = node switch

{

RoomNode roomNode => GetRoomColor(roomNode.RoomType),

EnemyNode => http://Color.red,

_ => Color.gray

};

// 绘制节点

Rect rect = new Rect(screenPosition.x - 50, screenPosition.y - 25, 100, 50);

EditorGUI.DrawRect(rect, new Color(color.r, color.g, color.b, 0.3f));

EditorGUI.DrawRect(new Rect(rect.x, rect.y, rect.width, 2), color);

// 绘制节点标签

GUIStyle style = new GUIStyle(http://GUI.skin.label)

{

alignment = TextAnchor.MiddleCenter,

normal = { textColor = Color.white }

};

GUI.Label(rect, node.title, style);

}

private static Color GetRoomColor(RoomType roomType)

{

return roomType switch

{

RoomType.Start => http://Color.green,

RoomType.Boss => http://Color.red,

RoomType.Treasure => Color.yellow,

http://RoomType.Shop => Color.magenta,

_ => http://Color.blue

};

}

private static void DrawEdgePreview(Edge edge, SceneView sceneView)

{

var startNode = edge.output.node as LevelNode;

var endNode = edge.input.node as LevelNode;

if (startNode == null || endNode == null) return;

Vector3 startPos = new Vector3(

startNode.GetPosition().position.x,

0,

startNode.GetPosition().position.y

);

Vector3 endPos = new Vector3(

endNode.GetPosition().position.x,

0,

endNode.GetPosition().position.y

);

// 绘制连接线

Handles.color = new Color(0.5f, 0.5f, 1f, 0.8f);

Handles.DrawDottedLine(startPos, endPos, 5f);

// 绘制箭头

Vector3 direction = (endPos - startPos).normalized;

float arrowSize = 10f;

Vector3 right = Quaternion.LookRotation(direction) Quaternion.Euler(0, 150, 0) Vector3.forward;

Vector3 left = Quaternion.LookRotation(direction) Quaternion.Euler(0, -150, 0) Vector3.forward;

Handles.DrawLine(endPos, endPos - right * arrowSize);

Handles.DrawLine(endPos, endPos - left * arrowSize);

}

private static void OnPlayModeChanged(PlayModeStateChange state)

{

// 进入播放模式时关闭预览

if (state == PlayModeStateChange.EnteredPlayMode)

{

showPreview = false;

}

else if (state == PlayModeStateChange.EnteredEditMode)

{

showPreview = true;

}

}

[MenuItem("Tools/关卡编辑器/切换预览")]

private static void TogglePreview()

{

showPreview = !showPreview;

SceneView.RepaintAll();

}

}

九、完整项目组织

1. 项目目录结构

text

Assets/

├── Editor/

│ ├── LevelGraphEditorWindow.cs

│ ├── LevelGraphView.cs

│ ├── Nodes/

│ │ ├── LevelNode.cs

│ │ ├── RoomNode.cs

│ │ ├── EnemyNode.cs

│ │ └── ItemNode.cs

│ ├── Utilities/

│ │ ├── LevelGraphSaveUtility.cs

│ │ ├── LevelGraphAutoLayout.cs

│ │ └── LevelGraphScenePreview.cs

│ └── LevelGraphStyles.uss

├── Scripts/

│ ├── LevelGeneration/

│ │ ├── LevelSceneGenerator.cs

│ │ ├── RoomComponent.cs

│ │ ├── PathComponent.cs

│ │ └── EnemyComponent.cs

│ └── Data/

│ ├── LevelGraphData.cs

│ └── NodeData.cs

├── LevelData/

│ └── (保存的.level文件)

├── Resources/

│ ├── Materials/

│ │ ├── RoomNormal.mat

│ │ ├── RoomStart.mat

│ │ ├── RoomBoss.mat

│ │ ├── RoomTreasure.mat

│ │ └── Wall.mat

│ └── Prefabs/

│ └── Enemy.prefab

└── Scenes/

└── GeneratedLevels/

└── (生成的场景文件)

2. 使用流程

打开编辑器:Tools → 关卡编辑器

创建节点:使用工具栏按钮创建房间、敌人等节点

连接节点:拖拽端口创建节点间连接

配置属性:在节点面板中设置各种参数

自动布局:右键菜单选择"自动排列"

保存关卡:点击保存按钮保存.level文件

生成场景:点击生成场景按钮创建Unity场景

实时预览:在Scene视图中查看关卡预览

十、性能优化建议

1. 编辑器性能

优化点 解决方案

大型关卡卡顿 实现节点虚拟化,只渲染可见区域节点

频繁刷新 使用脏标记系统,只有数据变化时刷新

内存占用 实现节点池,复用节点对象

2. 生成优化

csharp

// 异步场景生成

public async Task<GameObject> GenerateSceneAsync(LevelGraphData levelData)

{

GameObject levelRoot = new GameObject(levelData.LevelName + "_Generated");

// 分帧生成,避免卡顿

await GenerateRoomsAsync(levelData, levelRoot);

await Task.Delay(1); // 让出一帧

await GeneratePathsAsync(levelData, levelRoot);

await Task.Delay(1);

await GenerateGameObjectsAsync(levelData, levelRoot);

return levelRoot;

}

总结

本文详细介绍了基于Unity GraphView的可视化关卡编辑器的完整实现方案。通过这个系统,关卡设计师可以:

可视化设计:直观地拖拽节点创建关卡结构

逻辑连接:明确房间、敌人、道具之间的关联关系

数据驱动:所有配置数据化,便于版本管理和迭代

一键生成:自动将节点图转换为可玩的Unity场景

实时预览:在编辑器中即时查看关卡效果

该编辑器特别适合需要复杂关卡结构的游戏类型,如地牢探索、解谜冒险、RPG等。通过扩展节点类型,可以轻松适应不同游戏的需求,为关卡设计工作流带来革命性的效率提升。


免责声明:本文系网络转载或改编,未找到原创作者,版权归原作者所有。如涉及版权,请联系删

相关文章
技术文档
QR Code
微信扫一扫,欢迎咨询~
customer

online

联系我们
武汉格发信息技术有限公司
湖北省武汉市经开区科技园西路6号103孵化器
电话:155-2731-8020 座机:027-59821821
邮件:tanzw@gofarlic.com
Copyright © 2023 Gofarsoft Co.,Ltd. 保留所有权利
遇到许可问题?该如何解决!?
评估许可证实际采购量? 
不清楚软件许可证使用数据? 
收到软件厂商律师函!?  
想要少购买点许可证,节省费用? 
收到软件厂商侵权通告!?  
有正版license,但许可证不够用,需要新购? 
联系方式 board-phone 155-2731-8020
close1
预留信息,一起解决您的问题
* 姓名:
* 手机:

* 公司名称:

姓名不为空

姓名不为空

姓名不为空
手机不正确

手机不正确

手机不正确
公司不为空

公司不为空

公司不为空