untiy 3d结合Brainiac Designer做游戏Ai（一）

谈到游戏Ai，总是避免不了谈到行为树，虽然untiy3d有很多非常优秀的行为树插件可以实现Ai，但是很多都是已经被封装好了，不容易修改其中的源码，Brainiac Designer是一个非常好用的开源的行为树编辑器，可以生成cpp、lua、c#……等等代码，非常容易结合到游戏中，这里只介绍Brainiac Designer怎么跟unity3d结合实现Ai。

首先到http://brainiac.codeplex.com/ 下载Brainiac Designer的源码，然后生成一个Plugin，生成Plugin的方法看官网，这里不累赘，不过要注意一点是Plugin的.net framework的版本要用2.0。

生成Plugin后，我们来实现下面这个简单的Ai

这个Ai逻辑就是首先检测玩家是否在攻击范围内，是就是攻击，不是就看是否能找到玩家，找不到就巡逻，找到就追逐过去

我们在Brainiac Designer中新建一个顺序节点SequenceLinear.cs

using Brainiac.Design.Nodes;
using GameAi.Properties;
using System;
using System.Collections.Generic;
using System.Text;

namespace GameAi.Nodes
{
    public class SequenceLinear : Sequence
    {
        public SequenceLinear()
            : base(Resources.SequenceLinear, Resources.SequenceLinearDesc)
        {
        }
    }
}

再建一个选择节点SelectorLinear.cs

using Brainiac.Design.Nodes;
using GameAi.Properties;
using System;
using System.Collections.Generic;
using System.Text;

namespace GameAi.Nodes
{
    public class SelectorLinear : Selector
    {
        public SelectorLinear()
            : base(Resources.SelectorLinear, Resources.SelectorLinearDesc)
        {
        }
    }
}

建一个条件节点，玩家是否在攻击范围内，IsPlayerInAttackRange.cs

using Brainiac.Design.Nodes;
using GameAi.Properties;
using System;
using System.Collections.Generic;
using System.Text;

namespace GameAi.Nodes
{
    public class IsPlayerInAttackRange : Condition
    {
        public IsPlayerInAttackRange()
            : base(Resources.IsPlayerInAttackRange, Resources.IsPlayerInAttackRangeDesc)
		{
		}
    }
}

再建一个条件节点，能否找到玩家，CanNotFindPlayer.cs

using Brainiac.Design.Nodes;
using GameAi.Properties;
using System;
using System.Collections.Generic;
using System.Text;

namespace GameAi.Nodes
{
    public class CanNotFindPlayer: Condition
    {
        public CanNotFindPlayer()
            : base(Resources.CanNotFindPlayer, Resources.CanNotFindPlayer)
		{
		}
    }
}

再建一个条件节点，找到了玩家，FindPlayer.cs 

using Brainiac.Design.Nodes;
using GameAi.Properties;
using System;
using System.Collections.Generic;
using System.Text;

namespace GameAi.Nodes
{
    public class FindPlayer:Condition
    {
        public FindPlayer()
            : base(Resources.FindPlayer, Resources.FindPlayerDesc)
		{
		}
    }
}

我们建一个攻击的行为节点，Attack.cs

using Brainiac.Design.Nodes;
using GameAi.Properties;
using System;
using System.Collections.Generic;
using System.Text;

namespace GameAi.Nodes
{
    public class Attack : Action
    {
        public Attack()
            : base(Resources.Attack, Resources.AttackDesc)
		{
		}
    }
}

追逐的行为节点，Chase.cs

using Brainiac.Design.Nodes;
using GameAi.Properties;
using System;
using System.Collections.Generic;
using System.Text;

namespace GameAi.Nodes
{
    public class Chase:Action
    {
        public Chase()
            : base(Resources.Chase, Resources.ChaseDesc)
		{
		}
    }
}

巡逻节点，传一个参数，巡逻半径，Patrol.cs

using Brainiac.Design.Attributes;
using Brainiac.Design.Nodes;
using GameAi.Properties;
using System;
using System.Collections.Generic;
using System.Text;

namespace GameAi.Nodes
{
    public class Patrol:Action
    {
        protected int _patrolRange = 5;
        [DesignerInteger("_patrolRange", "ActionPatrolPropertyDesc", "CategoryBasic",
            DesignerProperty.DisplayMode.List, 0, DesignerProperty.DesignerFlags.NoFlags, 1, 10, 1, "UnitsMeters")]
        public int PatrolRange
        {
            get { return _patrolRange; }
            set { _patrolRange = value; }
        }

        protected override void CloneProperties(Brainiac.Design.Nodes.Node newnode)
		{
			base.CloneProperties(newnode);

			Patrol node= (Patrol)newnode;
            node._patrolRange = _patrolRange;
		}

        public Patrol()
            : base(Resources.Patrol, Resources.PatrolDesc)
		{
		}
    }
}

然后把这些节点都加到编辑器里

using Brainiac.Design;
using GameAi.Properties;
namespace GameAi
{
    public class GameAi:Plugin
    {
        public GameAi()
        {
            AddResourceManager(Resources.ResourceManager);
            _fileManagers.Add(new FileManagerInfo(typeof(Brainiac.Design.FileManagers.FileManagerXML), "Behavior XML (*.xml)|*.xml", ".xml"));
            _exporters.Add(new ExporterInfo(typeof(Exporters.ExportersCsUseGameAiFormat), "C# Behavior Exporter (Use GameAiFormat)", true, "C#Parameters"));
            NodeGroup actions = new NodeGroup(Resources.NodeGroupActions, NodeIcon.FlagBlue, null);
            _nodeGroups.Add(actions);
            actions.Items.Add(typeof(Nodes.Attack));
            actions.Items.Add(typeof(Nodes.Chase));
            actions.Items.Add(typeof(Nodes.Patrol));

            NodeGroup conditions = new NodeGroup(Resources.NodeGroupConditions, NodeIcon.FlagGreen, null);
            _nodeGroups.Add(conditions);
            conditions.Items.Add(typeof(Nodes.CanNotFindPlayer));
            conditions.Items.Add(typeof(Nodes.IsPlayerInAttackRange));
            conditions.Items.Add(typeof(Nodes.FindPlayer));

            NodeGroup selectorLinears = new NodeGroup(Resources.NodeGroupSelectorLinear, NodeIcon.FlagRed, null);
            _nodeGroups.Add(selectorLinears);
            selectorLinears.Items.Add(typeof(Nodes.SelectorLinear));

            NodeGroup sequenceLinears = new NodeGroup(Resources.NodeGroupSequenceLinear, NodeIcon.FlagRed, null);
            _nodeGroups.Add(sequenceLinears);
            sequenceLinears.Items.Add(typeof(Nodes.SequenceLinear));
        }
    }
}

编译就可以在编辑器看到刚才的那些节点了，按上面的图把各节点拖过去就可以得到刚才的那个行为树了

最后导出行为树的代码，可以导出很多种代码，只要新建一个类继承Exporter就可以定义自己导出的代码格式了，不过要配合在untiy写的Ai框架，这里给出一个示例

using Brainiac.Design;
using Brainiac.Design.Attributes;
using Brainiac.Design.Exporters;
using Brainiac.Design.Nodes;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace GameAi.Exporters
{
    public class ExportersCsUseGameAiFormat : Exporter
    {
        // the namespace the behaviours are exported to
        protected const string _usedNamespace = "GameAi";
        protected const string _parentClassName = "BehaviorTreeRoot";

        public ExportersCsUseGameAiFormat(BehaviorNode node, string outputFolder, string filename)
            : base(node, outputFolder, filename + ".cs")
		{
		}

        /// <summary>
        /// Exports a behaviour to the given file.
        /// </summary>
        /// <param name="file">The file we want to export to.</param>
        /// <param name="behavior">The behaviour we want to export.</param>
        protected void ExportBehavior(StreamWriter file, BehaviorNode behavior)
        {
            string namspace = _usedNamespace;
            string classname = Path.GetFileNameWithoutExtension(behavior.FileManager.Filename).Replace(" ", string.Empty);

            // write comments
            file.Write(string.Format("// Exported behavior: {0}\r\n", _filename));
            file.Write(string.Format("// Exported file:     {0}\r\n\r\n", behavior.FileManager.Filename));

            // create namespace and class
            file.Write(string.Format("namespace {0}\r\n{{\r\n", namspace));
            file.Write(string.Format("\tpublic sealed class {0} : {1}\r\n\t{{\r\n", classname, _parentClassName));

            // create instance and accessors
//             file.Write(string.Format("\t\tprivate static {0} _instance = null;\r\n", classname));
//             file.Write(string.Format("\t\tpublic static {0} Instance\r\n\t\t{{\r\n", classname));
//             file.Write("\t\t\tget\r\n\t\t\t{\r\n");
//             file.Write("\t\t\t\tif(_instance == null)\r\n");
//             file.Write(string.Format("\t\t\t\t\t_instance = new {0}();\r\n\r\n", classname));
//             file.Write("\t\t\t\treturn _instance;\r\n\t\t\t}\r\n\t\t}\r\n\r\n");

            // create constructor
            file.Write(string.Format("\t\tpublic {0}()\r\n\t\t{{\r\n", classname));

            // export nodes
            int nodeID = 0;

            // export the children
            foreach (Node child in ((Node)behavior).Children)
                ExportNode(file, namspace, behavior, "this", child, 3, ref nodeID);

            // close constructor
            file.Write("\t\t}\r\n");

            // close namespace and class
            file.Write("\t}\r\n}\r\n");
        }

        protected virtual void ExportConstructorAndProperties(StreamWriter file, Node node, string indent, string nodeName, string classname)
        {
            // create a new instance of the node
            file.Write(string.Format("{0}\t{2} {1} = new {2}();\r\n", indent, nodeName, classname));

            // assign all the properties
            ExportProperties(file, nodeName, node, indent);
        }

        /// <summary>
        /// Exports a node to the given file.
        /// </summary>
        /// <param name="file">The file we want to export to.</param>
        /// <param name="namspace">The namespace of the behaviour we are currently exporting.</param>
        /// <param name="behavior">The behaviour we are currently exporting.</param>
        /// <param name="parentName">The name of the variable of the node which is the parent of this node.</param>
        /// <param name="node">The node we want to export.</param>
        /// <param name="indentDepth">The indent of the ocde we are exporting.</param>
        /// <param name="nodeID">The current id used for generating the variables for the nodes.</param>
        protected void ExportNode(StreamWriter file, string namspace, BehaviorNode behavior, string parentName, 
            Node node, int indentDepth, ref int nodeID)
        {
            // generate some data
            string classname = node.ExportClass.Replace("GameAi.Nodes.", string.Empty);
            string nodeName = string.Format("node{0}", ++nodeID);

            // generate the indent string
            string indent = string.Empty;
            for (int i = 0; i < indentDepth; ++i)
                indent += '\t';

            string parentClassname = node.Parent.ExportClass;
            string addChildValue = (parentClassname.IndexOf("Decorator") != -1) ? "Proxy" : "AddChild";
            // we have to handle a referenced behaviour differently
            if (node is ReferencedBehaviorNode)
            {
                // generate the namespace and name of the behaviour we are referencing
                string refRelativeFilename = behavior.MakeRelative(((ReferencedBehaviorNode)node).ReferenceFilename);
                string refNamespace = GetNamespace(namspace, refRelativeFilename);
                string refBehaviorName = Path.GetFileNameWithoutExtension(((ReferencedBehaviorNode)node).
                    ReferenceFilename.Replace(" ", string.Empty));

                // simply add the instance of the behaviours we are referencing
                file.Write(string.Format("{0}{1}.{4}({2}.{3}.Instance);\r\n",
                    indent, parentName, refNamespace, refBehaviorName, addChildValue));
            }
            else
            {
                // open some brackets for a better formatting in the generated code
                file.Write(string.Format("{0}{{\r\n", indent));

                // export the constructor and the properties
                ExportConstructorAndProperties(file, node, indent, nodeName, classname);

                // add the node to its parent
                file.Write(string.Format("{0}\t{1}.{3}({2});\r\n", indent, parentName, nodeName, addChildValue));

                // export the child nodes
                foreach (Node child in node.Children)
                    ExportNode(file, namspace, behavior, nodeName, child, indentDepth + 1, ref nodeID);

                // close the brackets for a better formatting in the generated code
                file.Write(string.Format("{0}}}\r\n", indent));
            }
        }

        /// <summary>
        /// Exports all the properties of a ode and assigns them.
        /// </summary>
        /// <param name="file">The file we are exporting to.</param>
        /// <param name="nodeName">The name of the node we are setting the properties for.</param>
        /// <param name="node">The node whose properties we are exporting.</param>
        /// <param name="indent">The indent for the currently generated code.</param>
        protected void ExportProperties(StreamWriter file, string nodeName, Node node, string indent)
        {
            // export all the properties
            IList<DesignerPropertyInfo> properties = node.GetDesignerProperties();
            for (int p = 0; p < properties.Count; ++p)
            {
                // we skip properties which are not marked to be exported
                if (properties[p].Attribute.HasFlags(DesignerProperty.DesignerFlags.NoExport))
                    continue;

                // create the code which assigns the value to the node's property
                file.Write(string.Format("{0}\t{1}.{2} = {3};\r\n", indent, nodeName, properties[p].Property.Name, properties[p].GetExportValue(node).Replace("GameAi.", string.Empty)));
            }
        }

        /// <summary>
        /// Generates the namespace used for a referenced behaviour.
        /// </summary>
        /// <param name="currentNamespace">The namespace we are currently at.</param>
        /// <param name="relativeFilename">The relative filename of the ebhaviour we are referencing.</param>
        /// <returns></returns>
        protected string GetNamespace(string currentNamespace, string relativeFilename)
        {
            // if we stay in the same folder/namespace, just return the current one.
            if (Path.GetFileName(relativeFilename) == relativeFilename)
                return currentNamespace;

            // generate the namespace we are using
            string file = Path.GetDirectoryName(currentNamespace.Replace('.', '\\') + '\\' + relativeFilename);

            // make sure we remove any ..\ we found
            string full = Path.GetFullPath(file);
            string folder = Path.GetFullPath(".");

            Debug.Check(full.StartsWith(folder));

            // get a relative path for the namespace
            string namespaceFile = full.Substring(folder.Length + 1);

            // turn the path into a namespace and remove all spaces
            return namespaceFile.Replace('\\', '.').Replace(" ", string.Empty);
        }

        /// <summary>
        /// Export the assigned node to the assigned file.
        /// </summary>
        public override void Export()
        {
            // get the abolute folder of the file we want toexport
            string folder = Path.GetDirectoryName(_outputFolder + '\\' + _filename);

            // if the directory does not exist, create it
            if (!Directory.Exists(folder))
                Directory.CreateDirectory(folder);

            // export to the file
            StreamWriter file = new StreamWriter(_outputFolder + '\\' + _filename);
            ExportBehavior(file, _node);
            file.Close();
        }
    }
}

到这里Brainiac Designer部分已经差不多了，下一篇再讲怎么跟unity结合