Heath's Blog

There is no end, it is just the beginning! - A Game Developer's Notes

一个QTE原型框架

     QTE为Quick Time Event的简写，多见于主机游戏中，通常以在规定时间内根据提示完成（一系列）按键操作的形式出现。就表现上看，其实是过场动画的一种分解触发机制，用于表现看似复杂实则固定的动作或者场景效果，一方面在消除了单纯过场乏味感的同时增强了游戏的互动性，另一方面还降低了表现复杂效果的开发难度。

5_a 10_a

16_a 17_a

图1 QTE in GOD OF WAR III

     目前MMORPG的一个开发趋势就是融入主机游戏中的一些元素，提升网游在传统游戏性之外的可玩性。本文主要根据自己在项目中开发的QTE系统，介绍一个相对比较简单的原型框架。

一、分析

     以一个限时按键的QTE来分析，其中包括的元素有：时间、键、结果。时间与键可看作Event的约束条件，它们共同决定该Event是否达成。而结果可作为一条消息发送给关心者，然后由后者决定与之相关的表现。

Requirements Model

图2

     鼠标作为PC上重要的外设，当然会被用于QTE，其形式可能会包括：摇晃、按键、滚轮滚动等等。Event是否达成的判断流程，与限时按键大同小异。

     有时候Designer可能会设计一系列Event，增加操作难度，这时就需要考虑将多个Event串联起来，只有所有Event达成时，该QTE才能算达成。因此，在图1之上，需要加入另一个判断逻辑。

Requirements Model Extend

图3

二、实现

     通过分析，不难得出一个典型的QTE系统的核心数据结构：Event链表。此外，为了将结果反馈给QTE请求者，还应该提供一个通用的通知机制。在这个原型框架中，通过加入一个中间层来隔离异构的请求者，实现了回调机制。

System

图4

     QTEFunctor作为处理Event的仿函数基类，给出了各种QTE的处理接口。

Code Snippet
  1. class QTEFunctor
  2. {
  3. public:
  4.     QTE_TYPE m_type;
  5. protected:
  6.     float _fTimer;
  7.     float _fDuration;
  8.     unsigned int _uValue;    ///< condition
  9.     int _iRetValue;            ///< returned value
  10. public:
  11.     virtual QTEFUNCTOR_RETVAL operator() (float) = 0;
  12.     unsigned int GetValue() { return _iRetValue; }
  13. };
  14.  
  15. class MouseShakeFunctor : public QTEFunctor
  16. {
  17. private:
  18.     CPoint _point;
  19. public:
  20.     MouseShakeFunctor(const QTECondition&);
  21.     ~MouseShakeFunctor() {}
  22.     QTEFUNCTOR_RETVAL operator() (float);
  23. };
  24.  
  25. class KeyDownFunctor : public QTEFunctor
  26. {
  27. public:
  28.     KeyDownFunctor(const QTECondition&);
  29.     ~KeyDownFunctor() {}
  30.     QTEFUNCTOR_RETVAL operator() (float);
  31. };

     QTEDelegateBase提供了回调函数的统一接口，为兼容类函数和非类函数，分别派生出了QTETypeDelegate和QTENoTypeDelegate。

Code Snippet
  1. class QTEDelegateBase
  2. {
  3. public:
  4.     virtual void Call(QTEManager::QTE_TYPE , int) = 0;
  5.     virtual ~QTEDelegateBase() {}
  6. protected:
  7.     QTEDelegateBase() {}
  8. };
  9.  
  10. /// non-class method callback
  11. typedef void (*CallbackFuncPtrType)(QTEManager::QTE_TYPE , int);    ///< FAILED: second parameter <=0, OK : >0 (may include additional meanings)
  12. class QTENoTypeDelegate : public QTEDelegateBase
  13. {
  14. public:
  15.     QTENoTypeDelegate(CallbackFuncPtrType func) : _pCallbackFunc(func) {}
  16.     ~QTENoTypeDelegate() {}
  17.     void Call(QTEManager::QTE_TYPE , int) {}
  18. private:
  19.     CallbackFuncPtrType _pCallbackFunc;
  20. };
  21.  
  22. /// class method callback
  23. template<class C>
  24. class QTETypeDelegate : public QTEDelegateBase
  25. {
  26. public:
  27.     QTETypeDelegate(C* , void (C::*)(QTEManager::QTE_TYPE , int));
  28.     ~QTETypeDelegate() {}
  29.     void Call(QTEManager::QTE_TYPE , int);
  30. private:
  31.     C* _pObj;
  32.     void (C::*_pCallbackFunc)(QTEManager::QTE_TYPE , int);
  33. };
  34.  
  35. template<class C>
  36. QTETypeDelegate<C>::QTETypeDelegate(C* pObj , void (C::*func)(QTEManager::QTE_TYPE , int))
  37. : _pObj(pObj) , _pCallbackFunc(func)
  38. {
  39.  
  40. }
  41.  
  42. template<class C>
  43. void QTETypeDelegate<C>::Call(QTEManager::QTE_TYPE type , int value)
  44. {
  45.     (_pObj->*_pCallbackFunc)(type , value);
  46. }

     QTEManager中采用了vector容器来保存待处理的多个Event链，并提供申请QTE、取消QTE的接口，以及Event是否达成的逻辑更新。

Code Snippet
  1. void QTEManager::RequestQTE(QTEDelegateBase* pQTE , std::vector<QTECondition>& condList)
  2. {
  3.     std::vector<QTECondition>::iterator iter = condList.begin();
  4.     QTELinkNode* pNode = NULL;
  5.     QTELinkNode* pNextNode = NULL;
  6.  
  7.     for(; iter != condList.end(); ++iter)
  8.     {
  9.         if(pNextNode)
  10.         {
  11.             pNextNode->pNext = new QTELinkNode;
  12.             pNextNode = pNextNode->pNext;
  13.         }
  14.         else
  15.         {
  16.             pNode = new QTELinkNode;
  17.             pNextNode = pNode;
  18.         }
  19.  
  20.         switch(iter->type)
  21.         {
  22.         case QT_MOUSE_SHAKE:
  23.             pNextNode->pDelegate = pQTE;
  24.             pNextNode->pFunctor = new MouseShakeFunctor(*iter);
  25.             break;
  26.         case QT_KEY_DOWN:
  27.             pNextNode->pDelegate = pQTE;
  28.             pNextNode->pFunctor = new KeyDownFunctor(*iter);
  29.             break;
  30.         case QT_KEY_PRESS:
  31.             pNextNode->pDelegate = pQTE;
  32.             pNextNode->pFunctor = new KeyPressFunctor(*iter);
  33.             break;
  34.         }
  35.     }
  36.  
  37.     if(pNode)
  38.         _RequestList.push_back(pNode);
  39. }
  40.  
  41. void QTEManager::CancelQTE(QTEDelegateBase* pQTE)
  42. {
  43.     QTEListType::iterator iter = _RequestList.begin();
  44.  
  45.     for(; _RequestList.end() != iter; ++iter)
  46.     {
  47.         if(pQTE == (*iter)->pDelegate)
  48.         {
  49.             (*iter)->pDelegate->Call((*iter)->pFunctor->m_type , -1 , 0);    ///< failed
  50.  
  51.             QTELinkNode* pNode = *iter;
  52.             /// delete the rest node
  53.             while(pNode)
  54.             {
  55.                 *iter = pNode->pNext;
  56.                 delete pNode;
  57.                 pNode = *iter;
  58.             }
  59.             _RequestList.erase(iter);
  60.             break;
  61.         }
  62.     }
  63. }

 

Code Snippet
  1. #define STEP_OK_BASE 1000
  2. #define SUCCESS_BASE 2000
  3.  
  4. void QTEManager::Update(float dt)
  5. {    
  6.     QTEListType::iterator iter = _RequestList.begin();
  7.     for(; iter != _RequestList.end();)
  8.     {
  9.         QTEFUNCTOR_RETVAL ret = (*iter)->pFunctor->operator ()(dt);
  10.         if(QTEFR_FAILED == ret)
  11.         {
  12.             (*iter)->pDelegate->Call((*iter)->pFunctor->m_type , -1);    ///< failed
  13.  
  14.             QTELinkNode* pNode = *iter;
  15.             /// delete the rest event
  16.             while(pNode)
  17.             {
  18.                 *iter = pNode->pNext;
  19.                 delete pNode;
  20.                 pNode = *iter;
  21.             }
  22.             iter = _RequestList.erase(iter);
  23.         }
  24.         else if(QTEFR_OK == ret)
  25.         {
  26.             /// get next event
  27.             if((*iter)->pNext)
  28.             {
  29.                 QTELinkNode* pNode = *iter;
  30.                 pNode->pDelegate->Call(pNode->pFunctor->m_type ,
  31.                     STEP_OK_BASE + pNode->pFunctor->GetValue());        ///< step ok
  32.                 *iter = (*iter)->pNext;
  33.                 delete pNode;
  34.                 ++iter;
  35.             }
  36.             else
  37.             {
  38.                 (*iter)->pDelegate->Call((*iter)->pFunctor->m_type ,
  39.                     SUCCESS_BASE + (*iter)->pFunctor->GetValue());        ///< finally ok
  40.                 delete *iter;
  41.                 iter = _RequestList.erase(iter);
  42.             }
  43.         }
  44.         else if(QTEFR_PENDING == ret)
  45.         {
  46.             (*iter)->pDelegate->Call((*iter)->pFunctor->m_type ,
  47.                 (*iter)->pFunctor->GetValue());    ///< continue progressing
  48.             ++iter;
  49.         }
  50.     }
  51. }

posted on 2011-08-13 10:25 Heath 阅读(6173) 评论(4)  编辑 收藏 引用 所属分类: Game Development

Feedback

# re: 一个QTE原型框架 2011-08-13 18:11 战魂小筑

主机上都是用脚本写这层系统  回复  更多评论   

# re: 一个QTE原型框架 2011-12-09 11:50 周中良

请问那个class 图是用什么工具写的？谢谢！是rational rose吗？  回复  更多评论   

# re: 一个QTE原型框架[未登录] 2011-12-22 16:56 Heath

@周中良
EA  回复  更多评论   


只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理