private void createCube(int x, int y, int z)
{
var json = new NodeJson(NodeDataManager.NextName(NodeType.CUBE), new Vector3(x, y, z), Vector3.one * 5, "", NodeType.CUBE);
NodeDataManager.AddNode(json);
NodeFactory.CreateNode(json);
}
public void Export(BaseNode rootNode, string configName)
{
string configPath = BTUtils.GetGenPath() + configName + ".json";
string fullConfigPath = BTUtils.GetGenPath() + configName + "_full.json";
string nodeMapPath = BTUtils.GetGenPath() + configName + "_node_map.json";
Dictionary <string, BaseNodeData> baseNodeDataDict = new Dictionary <string, BaseNodeData>();
Dictionary <string, MergePyData> dataDict = new Dictionary <string, MergePyData>();
BTUtils.DumpTree(rootNode, (BaseNode node) =>
{
BaseNodeData nodeData = NodeDataManager.Get(node);
if (nodeData != null)
{
nodeData.Serialize(node);
dataDict[node.name] = new MergePyData(node);
baseNodeDataDict[node.name] = nodeData;
}
});
BTUtils.SaveJsonToFile <Dictionary <string, MergePyData> >(dataDict, configPath);
BaseNodeData rootNodeData = NodeDataManager.Get(rootNode);
BTUtils.SaveJsonToFile <BaseNodeData>(rootNodeData, fullConfigPath);
BTUtils.SaveJsonToFile <Dictionary <string, BaseNodeData> >(baseNodeDataDict, nodeMapPath);
}
public void Init()
{
NodeDataManager.Load("", new NodeJsonHolder());
this.cutter = GameObject.CreatePrimitive(PrimitiveType.Cube);
this.nodesCreated = new List <NodeJson>();
NodeHoleCutter.ResetIgnores();
}
public static ConnectionPoint CreateConnectionPoint(BaseNode node, ConnectionPointType type)
{
ConnectionPoint connectionPoint = new ConnectionPoint(node, type);
//new Data
NodeDataManager.CreateConnectionPointData(connectionPoint);
connectionPoint_list.Add(connectionPoint);
return(connectionPoint);
}
public static Connection CreateConnection(ConnectionPoint outPoint, ConnectionPoint inPoint)
{
Connection connection = new Connection(outPoint, inPoint, OnClickRemoveConnection);
//new Data
NodeDataManager.CreateConnectionData(connection);
connection_list.Add(connection);
return(connection);
}
public virtual void Serialize(BaseNode node)
{
base.SetId(node);
this.name = node.name;
this.x = (int)node.rect.x;
this.y = (int)node.rect.y;
this.outPoint = NodeDataManager.Get(node.outPoint);
this.inPoint = NodeDataManager.Get(node.inPoint);
this.properties = node.properties;
}
public static void RemoveTree(BaseNode node)
{
NodeDataManager.Remove(node);
if (node.childs.Count > 0)
{
for (int i = 0; i < node.childs.Count; i++)
{
DumpTree(node.childs[i]);
}
}
}
public static void SaveCurrentConnection()
{
if (selectedConnection != null)
{
ConnectionData data = NodeDataManager.Get(selectedConnection);
if (data != null)
{
data.Serialize(selectedConnection);
}
}
}
private void RemoveTreeConnection()
{
//out's child remove in
this.outPoint.node.childs.Remove(this.inPoint.node);
//out's child remove in
BaseNodeData outNodeData = NodeDataManager.Get(this.outPoint.node);
BaseNodeData inNodeData = NodeDataManager.Get(this.inPoint.node);
NodeDataManager.Remove(this, outNodeData);
}
public static void SaveCurrentNode()
{
if (selectedNode != null)
{
BaseNodeData nodeData = NodeDataManager.Get(selectedNode);
if (nodeData != null)
{
nodeData.Serialize(selectedNode);
}
}
}
public void Cuts2HoleInNonUniformRoom()
{
Init();
var cube1 = new NodeJson(NodeDataManager.NextName(NodeType.CUBE), new Vector3(0, 0, 0), new Vector3(4, 3, 5), "", NodeType.CUBE);
NodeDataManager.AddNode(cube1);
NodeFactory.CreateNode(cube1);
var cube2 = new NodeJson(NodeDataManager.NextName(NodeType.CUBE), new Vector3(6, 0, 0), new Vector3(6, 5, 4), "", NodeType.CUBE);
NodeDataManager.AddNode(cube2);
NodeFactory.CreateNode(cube2);
runCutHoleTest(
new Vector3(2.5f, -0.5f, 1f),
new Vector3(2, 0.5f, 0.8f),
(hole) => {
if (hole.behaviour.name.Contains("right"))
{
Assert.AreApproximatelyEqual(-1f, hole.position.x, "hole has wrong X pos");
Assert.AreApproximatelyEqual(-0.5f, hole.position.y, "hole has wrong Y pos");
Assert.AreApproximatelyEqual(0.8f, hole.scale.x, "hole has wrong X sca");
Assert.AreApproximatelyEqual(0.5f, hole.scale.y, "hole has wrong Y sca");
}
if (hole.behaviour.name.Contains("left"))
{
Assert.AreApproximatelyEqual(1f, hole.position.x, "hole has wrong X pos");
Assert.AreApproximatelyEqual(-0.5f, hole.position.y, "hole has wrong Y pos");
Assert.AreApproximatelyEqual(0.8f, hole.scale.x, "hole has wrong X sca");
Assert.AreApproximatelyEqual(0.5f, hole.scale.y, "hole has wrong Y sca");
}
});
this.nodesCreated.Clear();
runCutHoleTest(
new Vector3(2.5f, 0.75f, -0.5f),
new Vector3(2, 0.5f, 0.8f),
(hole) => {
if (hole.behaviour.name.Contains("right"))
{
Assert.AreApproximatelyEqual(0.1f, hole.position.x, "hole has wrong X pos");
Assert.AreApproximatelyEqual(0.125f / 3f, hole.position.y, "hole has wrong Y pos");
Assert.AreApproximatelyEqual(0.16f, hole.scale.x, "hole has wrong X sca");
Assert.AreApproximatelyEqual(0.5f / 3f, hole.scale.y, "hole has wrong Y sca");
}
if (hole.behaviour.name.Contains("left"))
{
Assert.AreApproximatelyEqual(-0.125f, hole.position.x, "hole has wrong X pos");
Assert.AreApproximatelyEqual(-0.075f, hole.position.y, "hole has wrong Y pos");
Assert.AreApproximatelyEqual(0.2f, hole.scale.x, "hole has wrong X sca");
Assert.AreApproximatelyEqual(0.1f, hole.scale.y, "hole has wrong Y sca");
}
});
CleanUp();
}
private void BuildTreeConnection()
{
//out's child is in
this.outPoint.node.childs.Add(this.inPoint.node);
//out's child is in
BaseNodeData outNodeData = NodeDataManager.Get(this.outPoint.node);
BaseNodeData inNodeData = NodeDataManager.Get(this.inPoint.node);
ConnectionData connectionData = NodeDataManager.CreateConnectionData(this);
connectionData.targetNodeId = inNodeData.id;
outNodeData.connectionList.Add(connectionData);
}
public static void ShowWindow()
{
if (_window == null)
{
_window = EditorWindow.GetWindow <BTEditorWindow>();
}
Reset();
Vector2 initPosition = new Vector2(10, _window.position.height / 2 - 25);
//BaseNode root = BTEditorManager.AddRootNode(initPosition);
NodeDataManager.Reset();
BTEditorManager.Reset();
}
public virtual void DeSerialize(ref BaseNode node)
{
BaseNodeData oldData = NodeDataManager.Get(node);
//this可能不是node对应的那份数据
oldData.Sync(this);
node.id = this.id;
node.name = this.name;
node.rect.x = this.x;
node.rect.y = this.y;
//node.outPoint = BTEditorManager.GetObject<ConnectionPoint>(this.outPoint);
//node.inPoint = BTEditorManager.GetObject<ConnectionPoint>(this.inPoint);
node.properties = this.properties;
}
public virtual void Serialize(Connection connection)
{
base.SetId(connection);
//Debug.Log(">connection data " + this.id);
this.connectId = connection.connectId;
this.slotList.Clear();
foreach (SlotData slot in connection.slotList)
{
this.slotList.Add(slot);
}
this.outPoint = NodeDataManager.Get(connection.outPoint);
this.inPoint = NodeDataManager.Get(connection.inPoint);
}
public void CutHoleWhenParentHaveScale()
{
Init();
// create cube inside of empty with scale, but cube is still 5*5*5 to world
var empty1Json = new NodeJson("empty1Json", new Vector3(0, 0, 0), new Vector3(5, 2, 1), "", NodeType.EMPTY);
NodeDataManager.AddNode(empty1Json);
var empty2Json = new NodeJson("empty2Json", new Vector3(0, 0, 0), new Vector3(1, 2, 2), "", NodeType.EMPTY)
{
parentName = "empty1Json"
};
NodeDataManager.AddNode(empty2Json);
var cubeJson = new NodeJson("cubeJson", new Vector3(0, 0, 0), new Vector3(1, 1.2f, 2.4f), "", NodeType.CUBE)
{
parentName = "empty2Json"
};
NodeDataManager.AddNode(cubeJson);
NodeFactory.CreateNodes(NodeDataManager.NodeJsons);
var cutterPos = new Vector3(3, 0.5f, -1);
var cutterSca = new Vector3(2, 2, 2);
this.cutter.transform.position = cutterPos;
this.cutter.transform.localScale = cutterSca;
Debug.Log(string.Format("testing cutter with pos:{0} sca:{1}", cutterPos, cutterSca));
NodeDataManager.onAddNode += this.onAddNode;
NodeHoleCutter.CutHoles(this.cutter);
var holeCount = 1;
Assert.AreEqual(holeCount, this.nodesCreated.Count, string.Format("There are not {0} holes", holeCount));
foreach (var hole in this.nodesCreated)
{
Assert.AreEqual(NodeType.HOLE, hole.nodeType);
Assert.AreApproximatelyEqual(0.2f, hole.position.x, "hole has wrong X pos");
Assert.AreApproximatelyEqual(0.125f, hole.position.y, "hole has wrong Y pos");
Assert.AreApproximatelyEqual(0.4f, hole.scale.x, "hole has wrong X sca");
Assert.AreApproximatelyEqual(0.5f, hole.scale.y, "hole has wrong Y sca");
}
NodeDataManager.onAddNode -= this.onAddNode;
CleanUp();
}
private void DrawSlots()
{
var connection = BTEditorManager.selectedConnection;
GUILayout.Space(20);
GUILayout.BeginHorizontal();
GUILayout.Label("Name", GUILayout.MaxWidth(80));
connection.connectId = EditorGUILayout.TextArea(connection.connectId, GUILayout.MaxHeight(25));
GUILayout.EndHorizontal();
GUILayout.Label("Slots");
for (int i = 0; i < connection.slotList.Count; i++)
{
GUILayout.BeginHorizontal("");
connection.slotList[i].out_slot = EditorGUILayout.TextArea(connection.slotList[i].out_slot, GUILayout.MaxHeight(25));
connection.slotList[i].in_slot = EditorGUILayout.TextArea(connection.slotList[i].in_slot, GUILayout.MaxHeight(25));
if (GUILayout.Button("-", GUILayout.MaxWidth(50)))
{
_slots_remove_list.Add(connection.slotList[i]);
}
GUILayout.EndHorizontal();
}
for (int i = 0; i < _slots_remove_list.Count; i++)
{
SlotData remove_key = _slots_remove_list[i];
connection.slotList.Remove(remove_key);
GUI.changed = true;
}
_slots_remove_list.Clear();
if (GUILayout.Button("+", GUILayout.MaxWidth(50)))
{
var connectionData = NodeDataManager.Get(connection);
SlotData slotData = new SlotData();
slotData.SetupConnect(connectionData);
connection.slotList.Add(slotData);
GUI.changed = true;
}
}
public MergePyData(BaseNode node)
{
this.connections = new List <Dictionary <string, string> >();
if (node.type == NodeType.ExcelNode)
{
ExcelNodeData data = (ExcelNodeData)NodeDataManager.Get(node);
if (data != null)
{
this.name = data.name;
this.file = data.file;
this.is_collect_info = false;
if (data.properties.ContainsKey("is_collect_info") && data.properties["is_collect_info"][0] == "True")
{
this.is_collect_info = true;
}
if (data.connectionList != null)
{
foreach (ConnectionData connection in data.connectionList)
{
foreach (SlotData slotData in connection.slotList)
{
Dictionary <string, string> slotDic = new Dictionary <string, string>()
{
{ "in_slot", slotData.in_slot },
{ "node", slotData.node },
{ "out_slot", slotData.out_slot }
};
connections.Add(slotDic);
}
}
}
}
}
}
private static BaseNode __addNode(NodeType node_type, Vector2 mousePosition)
{
BaseNode node = null;
switch (node_type)
{
case NodeType.BehaviourNode:
node = new BehaviourNode();
node.Init(mousePosition, OnClickNode);
NodeDataManager.CreateNodeData <BaseNodeData>(node);
nodes_list.Add(node);
break;
case NodeType.ExcelNode:
node = new ExcelNode();
node.Init(mousePosition, OnClickNode);
NodeDataManager.CreateNodeData <ExcelNodeData>(node);
nodes_list.Add(node);
break;
case NodeType.ActionNode:
node = new ActionNode();
node.Init(mousePosition, OnClickNode);
NodeDataManager.CreateNodeData <BaseNodeData>(node);
nodes_list.Add(node);
break;
case NodeType.ConditionNode:
node = new ConditionNode();
node.Init(mousePosition, OnClickNode);
NodeDataManager.CreateNodeData <BaseNodeData>(node);
nodes_list.Add(node);
break;
case NodeType.WaitNode:
node = new WaitNode();
node.Init(mousePosition, OnClickNode);
NodeDataManager.CreateNodeData <BaseNodeData>(node);
nodes_list.Add(node);
break;
case NodeType.SequenceNode:
node = new SequenceNode();
node.Init(mousePosition, OnClickNode);
NodeDataManager.CreateNodeData <BaseNodeData>(node);
nodes_list.Add(node);
break;
case NodeType.SelectorNode:
node = new SelectorNode();
node.Init(mousePosition, OnClickNode);
NodeDataManager.CreateNodeData <BaseNodeData>(node);
nodes_list.Add(node);
break;
case NodeType.LoopNode:
node = new LoopNode();
node.Init(mousePosition, OnClickNode);
NodeDataManager.CreateNodeData <BaseNodeData>(node);
nodes_list.Add(node);
break;
}
if (node != null && nodes_list.Count == 1)
{
rootNode = node;
}
return(node);
}
public void CleanUp()
{
Object.DestroyImmediate(this.cutter);
NodeDataManager.Unload();
this.nodesCreated = null;
}
