项目希望能够实现一些剧情动画,类似角色移动,镜头变化,台词展现等.剧情动画这东西随时需要修改调整,不能写死在代码里.考虑之后认为需要做一个简单的DSL来定制剧情脚本,策划在脚本里按顺序写入命令,然后我们解释命令执行即可.

　　项目的很多功能系统并没有能够实现导入lua中,非我所能决定,若可以则使用lua方便不少.因此我决定使用C++来制作这个剧情脚本DSL.

　　使用boost的spirit来负责脚本的解析,使用asio的coroutine简化了指令处理逻辑.

　　DSL当然不能太复杂,第一个版本看起来类似:

role_walk	LEFT		100;

role_dialog	"stop!!!"	4;

role_jump	FORWARD;

role_walk	RIGHT		200;

monster_dialog	"byebye!!!"	2;

monster_run	RIGHT		400

role_walk	RIGHT		500;

role_jump	BACK;

　　稍加按上边指令流程走下来,会发现一些指令是有延时性的.比如走,跑等,都需要移动到目标地点才算结束.当遇到这个指令时,我们是继续往下解析指令,还是在当前指令阻塞呢?遇到指令立即解析执行,那很可能在一帧里就把脚本的所有指令都执行完毕了,本来30秒的剧情在不到1/60秒里结束了.如果遇到延时性指令立即阻塞呢,会遇到可能有几条延时性指令同时开始的场景.因此决定再加上一个规则,使用方括号括起来的脚本指令,将强制同时执行,第二版本如下:

role_walk	LEFT		100;

role_dialog	"stop!!!"	4;

role_jump	FORWARD;

role_walk	RIGHT		200;

monster_dialog	"byebye!!!"	2;

[

monster_run	RIGHT		400

role_walk	RIGHT		500;

]

role_jump	BACK;   　

　至此我认为脚本的规则能适应足够多场景了.该脚本暂不需要控制结构,控制条件在脚本进行时都预先知道了.

　这是脚本解析代码.

#ifndef __MovieCommandAST_H__

#define __MovieCommandAST_H__

#include <boost/fusion/include/adapt_struct.hpp>

#include <boost/variant/variant.hpp>

#include <boost/variant/recursive_variant.hpp>

#include <boost/fusion/include/std_pair.hpp>

namespace MovieScript

{

    typedef boost::variant<std::string, int, float>        ArgType;

    typedef std::vector<ArgType>                        ArgList;

    namespace Parser

    {

        struct command_atom

        {

            std::string        cmd;

            ArgList            args;

            command_atom():cmd("") {}

        };

        struct command_flow;

        typedef boost::variant<boost::recursive_wrapper<command_flow>, command_atom> command_unit;

        typedef std::list<command_unit> CommandUnitList;

        struct command_flow

        {

            CommandUnitList cmd_flow;

        };

    }

}

BOOST_FUSION_ADAPT_STRUCT

(

MovieScript::Parser::command_atom,

(std::string, cmd)

(MovieScript::ArgList, args)

)

BOOST_FUSION_ADAPT_STRUCT

(

MovieScript::Parser::command_flow,

(MovieScript::Parser::CommandUnitList, cmd_flow)

)

#endif
#ifndef __MovieCommandEnumParser_H__

#define __MovieCommandEnumParser_H__

#include <boost/spirit/include/phoenix_operator.hpp>

#include <boost/spirit/include/qi.hpp>

#include <boost/config/warning_disable.hpp>

namespace MovieScript

{

    namespace fusion = boost::fusion;

    namespace qi = boost::spirit::qi;

    namespace phoenix = boost::phoenix;

    namespace ascii = boost::spirit::ascii;

    namespace Parser

    {

        struct Enum_ : qi::symbols<char, int>

        {

            Enum_()

            {

                add

                    ("LEFT"    , )

                    ("RIGHT"   , )

                    ("FORWARD"  ,)

                    ("BACK"   , )

                    ("STAY"   , )

                    ;

            }

        } Enum;        

        template <typename Iterator>

        struct EnumParser : qi::grammar<Iterator, int()>

        {

            EnumParser() : EnumParser::base_type(start)

            {

                using qi::eps;

                using qi::lit;

                using qi::_val;

                using qi::_1;

                using ascii::char_;

                start = eps [_val = ] >>

                    ( Enum    [_val += _1] )

                    ;

            }

            qi::rule<Iterator, int()> start;

        };

    }

}

#endif
#ifndef __MovieCommandParser_H__

#define __MovieCommandParser_H__

#include <boost/spirit/include/qi.hpp>

#include <boost/config/warning_disable.hpp>

#include <boost/fusion/include/std_pair.hpp>

#include <boost/spirit/include/phoenix_object.hpp>

#include <boost/spirit/include/phoenix_core.hpp>

#include <boost/spirit/include/phoenix_operator.hpp>

#include <boost/spirit/include/phoenix_fusion.hpp>

#include "MovieCommandAST.h"

namespace MovieScript

{

    namespace fusion = boost::fusion;

    namespace qi = boost::spirit::qi;

    namespace phoenix = boost::phoenix;

    namespace ascii = boost::spirit::ascii;

    namespace Parser

    {

        template<typename Iter>

        struct commnent_grammar : qi::grammar<Iter>

        {

            qi::rule<Iter> _skipper;

            commnent_grammar():base_type(_skipper)

            {

                using qi::eol;

                using qi::omit;

                using ascii::char_;

                using ascii::blank;

                using qi::lit;

                _skipper = omit[lit("//") >> *(char_ - eol)] | blank;

            }

        };

        template <typename Iterator>

        struct cmd_grammar : qi::grammar<Iterator, command_flow(), commnent_grammar<Iterator>>

        {

            typedef commnent_grammar<Iterator> skipper;

            qi::rule<Iterator, command_flow(), skipper> cmd_flow;

            qi::rule<Iterator, command_unit(), skipper> cmd_unit;

            qi::rule<Iterator, command_atom(), skipper> cmd_atom;

            qi::rule<Iterator, std::string(), skipper>  cmd_name, enum_name;

            qi::rule<Iterator, ArgType(), skipper>      argtype;

            qi::rule<Iterator, ArgList(), skipper>      arglist;

            cmd_grammar() : cmd_grammar::base_type(cmd_flow)

            {

                using qi::lit;

                using qi::lexeme;

                using qi::int_;

                using qi::float_;

                using qi::eps;

                using qi::eol;

                using qi::bool_;

                using ascii::char_;

                using ascii::alpha;

                using ascii::alnum;

                using ascii::string;

                using namespace qi::labels;

                using phoenix::construct;

                using qi::on_error;

                using qi::fail;

                using qi::debug;

                cmd_name =    lexeme[ +(alpha | alnum | char_('_')) ];

                enum_name = lexeme[ +(alpha | alnum | char_('_')) ];

                argtype = float_ | bool_ | enum_name ;

                cmd_atom =    cmd_name >> *(argtype) ;

                cmd_unit =    (lit('[') >> +eol >> cmd_flow >> +eol >> lit(']')) | (cmd_atom);

                cmd_flow =    eps >> *eol >> cmd_unit % (+eol);

            }

        };

    }

}

#endif

上边代码将指令流看做是可递归的.方括号内的指令集仍可包含方括号.虽然暂时用不上,但这个概念是有用的.今后可修改规则令指令流可递归解析及执行.没有解析双引号,为了本地化方便,台词使用序号索引.这个脚本称不上语言,若想添加与游戏内联系的变量,控制结构等,还需要一个中间数据结构来与游戏传递消息,保存状态.这已经超出了该脚本的设定功能.但若真要深入做下去,显然需要实现这些.那就相当于做一个类似lua的语言了,这不只是单靠spirit所能解决的问题.

　　现在来看下脚本处理流程.

　　1　　扫描脚本文件,按顺序解析出一个指令链表.

　　2　　读取指令链表,每遇到指令则推送,如果遇到方括号,则推送方括号内的所有指令.

　　4　　接收推送的指令,如果是即时性的指令,立即执行.如果是延时性的指令,需要一个判断条件,未达成则一直执行.

　　5　　回到2.

　　6 　　读到链表结尾,剧情脚本结束.

　　

　　推送指令然后执行类似一个管道流操作,或者可以看做生产者和消费者的关系.处理这种场景使用协程能将程序逻辑写的很自然.如下是我的代码片段.使用协程,在一个循环里处理了推送指令和执行2个动作.

bool Processer::pump()

{

    static CommandUnitList::const_iterator it;

    reenter(&coro_stream)

    {

        for(it = g_cmd_glows.cmd_flow.begin(); it != g_cmd_glows.cmd_flow.end();)

        {

            if( ! is_block() ) {

                boost::apply_visitor(command_flow_handler(this), *it);

                block();

                yield return true;

            }

            execute();

            yield return true;

        }

        shutdown();

        yield return false;

    }

    return false;

}

pump每帧都被调用.但是reenter(&coro_stream){ ... } 内的for循环每次只执行一步,而非全部执行.首先执行boost::apply_vistor读取指令,下一个循环将执行execute(),若block标志被改变,则继续读取指令.在一个循环里实现了异步顺序处理.没有协程不是说做不了,但使用协程,就可以在短短的这个循环里写出清晰简单的逻辑.

不满意的地方是对指令的抽象.当等到推送指令后(实际上只是一个包含指令名字和参数的结构),我们需要把它构建为一个游戏能真正执行的指令,就是转化为对游戏功能执行函数的调用.我的本意是将游戏功能执行函数绑定到指令上,令指令与具体的游戏功能解耦.实际遇到一个参数传递的问题.从脚本解析出来的参数,放在一个vector里.除非游戏功能执行函数直接以这个vector作为输入参数,否则必须将vector逐个元素解开再传入.问题来了,每条指令参数的类型,数量都是不同的,于是每条指令不得不也是"特定"的.如果你有一个指令基类,也许就意味着每条指令就是一个子类.若c++参数能在类似lua在调用处展开(lua参数实际是table),无疑很有用.没找到好的办法.仍用传统的类结构实现指令.

        class ICommandExecutor

        {

            command_atom cmd_atom;

            Private::coroutine coro_executor;

        public:

            ICommandExecutor();

            ICommandExecutor(const command_atom& cmd_atom_);

            ICommandExecutor(const ICommandExecutor& cmd);

            bool execute();

            void setdowned() { _downed = true; }

            template<class ReturnType>

            ReturnType getValue(int pos)

            {

                return boost::get<ReturnType>(cmd_atom.args.at(pos));

            }

        protected:

            virtual bool run_exec();

            virtual bool enter_exec();

            virtual bool leave_exec();

            virtual bool downed();

            bool _downed;

        };

指令的执行仍可利用协程改善逻辑.execute()的实现:

bool ICommandExecutor::execute()

{

    reenter(&coro_executor)

    {

        yield return enter_exec();

        while(!downed())

        {

            yield return run_exec();

        }

        yield return leave_exec();

    }

    return false;

}

这里我把指令运行分为了进入,运行,离开三个阶段.实现这三个阶段的顺序实现需要某种状态机制.而使用协程,逻辑看起来就清爽了.

一个简单的指令工厂.

        class CommandFactory

        {

        public:

            typedef boost::function< ICommandExecutor*(const command_atom&) >    CreateCommandFunction;

            typedef Loki::SingletonHolder<CommandFactory>                        MySingleton;

            inline static CommandFactory& Instance()

            { return MySingleton::Instance(); }

            ICommandExecutor* create(const command_atom& cmd_atom);

            void register_commnad(const std::string& cmdname, CreateCommandFunction creator);

        private:

            typedef std::map<std::string, CreateCommandFunction>    IdToCommandMap;

            IdToCommandMap    id_to_command_map;

        };

        template<class CommandExecutorType>

        class CommandExecutorNew

        {

        public:

            static ICommandExecutor* create(const command_atom& cmd_atom)

            {

                return new CommandExecutorType(cmd_atom);

            }

        };

最新文章

  1. linux重启mysql无法启动
  2. 入口点函数的19种消息，AcRxArxApp只处理16种。
  3. 手把手教你cuda5.5与VS2010的编译环境搭建
  4. [转]C#设置WinForm快捷键
  5. Worker、Task、Executor三者之间的关系
  6. Android 进入另外一个窗体的两种方法
  7. [转载]CTO和技术总监区别
  8. android监听键盘
  9. SQL Server 备份维护计划
  10. Android手机安全软件的恶意程序检测靠谱吗--LBE安全大师、腾讯手机管家、360手机卫士恶意软件检测方法研究
  11. 网络编程（UDP协议-聊天程序）
  12. Centos 下安装Zabbix Linux 客户端
  13. Git 直接推送到生产服务器
  14. Vue中引入bootstrap导致的CSS问题
  15. week5
  16. Akka-CQRS（5）- CQRS Writer Actor 部署和测试
  17. CentOS 7 配置Tomcat9连接MySQL
  18. get UI URL
  19. Leetcode——58.最后一个单词的长度
  20. Android避免OOM（内存优化）

热门文章

  1. 实用Linux命令，不求最全但求实用-------iptables命令实战
  2. Android处理Bitmap的一些方法
  3. 最短JS判断是否为IE6(IE的写法) (转)
  4. ccnu-线段树-简单的区间更新（三题）
  5. SQLServer2008 行转列
  6. 下拉刷新控件(3)系统自带的下拉刷新控件SwipeRefreshLayout（推荐*）
  7. Types of Entity in Entity Framework:
  8. list::splice()函数详解
  9. Linux进程控制（三）
  10. HDU 2147 (博弈) kiki&#39;s game