一个QTE原型框架

一个QTE原型框架

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

 

 

图1 QTE in GOD OF WAR III

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

一、分析

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

图2

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

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

图3

二、实现

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

图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. }