任务系统之服务端部分

这里是服务端任务数据的读取 这里我只是写了一个简短的，读取方式这个的看你们自己项目策划的要求是什么类型的任务，这里读取的也只是一个静态数据xml表,

#ifndef __BRUCE_GAME_QUESTXMLVO__HEADER__
#define __BRUCE_GAME_QUESTXMLVO__HEADER__

#include <typedef.hpp>

GAME_NS_BEGIN


//常量任务读取字段;
class QuestXmlVo 
{
public:
    //  任务ID；
    BRUCE_SYNTHESIZE_PASS_BY_REF(int, m_nQuestID, QuestID);

    //任务线;
    BRUCE_SYNTHESIZE_PASS_BY_REF(int, m_nQuestGroup, QuestGroup);

    //  任务类型;
    BRUCE_SYNTHESIZE_PASS_BY_REF(int, m_nQuestType, QuestType);

    //  任务次数;
    BRUCE_SYNTHESIZE_PASS_BY_REF(int, m_nQuestCoin, QuestCoin);

};

APP_NS_END

“QuestSystem.h”
这个文件 还有这个文件的cpp 是获取服务端那边过来的任务的数据，比如完成的，或者没完成的提交的信息或到数据库中去查询，任务的处理这些;这些都是我将自己做的然后自己写的一个简单的实例出来。掌握这样做运行的起来，不吭坑你们这些初学者的 坑你们我又得不到什么.注释也写的比较详细.我还是那句话师傅领进门 修行靠自己。

ifndef __BRUCE_GAME_QUEST_SYSTEM_HEADER__
#define __BRUCE_GAME_QUEST_SYSTEM_HEADER__

#include "typedef.hpp"
#include <Network.hpp>
#include <GameServer/Quest.hpp>
#include "QuestCommon.hpp"
#include "Character.hpp"
#include <vector>
#include "QuesXmlVo.hpp"


GAME_NS_BEGIN

//任务类型;
enum 
{
    QUEST_MISSION_ORDINARY,                         //关卡的类型任务类型;
    QUEST_MISSION_ELITE,                            //精英关卡任务类型;
    QUEST_TIME_ORDINARY,                            //时光之穴的任务类型;
    QUEST_TIME_ELITE


};

class QuestSystem
{
public:
    QuestSystem();
    ~QuestSystem();

    int         initialize();

    void            finalize();

    //接收客户端到服服务端的任务请求信息;
    void handleClientToSeverQuestInfoReq(Message::Ptr& message);

    //去寻找当前提交的任务信息是否与与关卡中的相匹配;
    void QueryMissionInfo(C2GS_QuestSubmitReq xQuestSubmitReq, int n_QusetType);

    //关卡获取的任务是否达到次数条件的信息与当前提交的任务的信息进行比较，如果条件达到就删除该数据，如果没有达到就返回Reuct=1;
    void QuestJudgeInfoAck(Message::Ptr &message);

    //删除任务信息的返回;
    void QuestDeleteInfoAck(Message::Ptr &message);

    //保存已完成的任务;
    void QuestSeaveCurrentlyInfo(Message::Ptr &message);

public:
    QuestXmlVo* getQuestXmlVo(int n_QuestId);

// 容器共有;
public:
    typedef std::map<int, QuestXmlVo*> TaskInof;
    TaskInof n_TaskInfo;

private:
    //  Xml信息加载;
    void QuestVoInof();


    BRUCE_SYNTHESIZE(QuestIdVec, m_questVec,QusetId)
};




APP_NS_END

#endif // !__BRUCE_GAME_QUEST_SYSTEM_HEADER__

“QuestSystem.cpp”

#include "QuestSystem.hpp"
#include "ServerData.hpp"
#include "CharMgr.hpp"
#include <tinyxml/tinyxml.h>


GAME_NS_BEGIN

QuestSystem::QuestSystem()
{
    QuestVoInof();
}


QuestSystem::~QuestSystem()
{

}

int QuestSystem::initialize()
{

    //接收从DB中查询角色任务的结果;
    //DEFREG_MESSAGE(ID_DS2GS_QuestSqlAck, QuestSystem, handleDBToGameSeverQuestInfoAck)
    //DEFREG_MESSAGE(ID_DS2GS_QuestSqlAck, QuestSystem, handleClientToSeverQuestInfoReq)

    //接收过来的任务请求;
    DEFREG_MESSAGE(ID_C2GS_QuestSubmitReq, QuestSystem, handleClientToSeverQuestInfoReq)

    DEFREG_MESSAGE(ID_DS2GS_QuestGetMissonCountInfoAck, QuestSystem, QuestJudgeInfoAck)

    DEFREG_MESSAGE(ID_DS2GS_QuesDeleteSqlInfoAck, QuestSystem, QuestDeleteInfoAck)

    DEFREG_MESSAGE(ID_DS2GS_QuestDeltAndSeaveInfoAck, QuestSystem, QuestSeaveCurrentlyInfo)

    return 0;
}

void QuestSystem::finalize()
{
    //QuestVoInof();
} 

//接收提交任务请求;handleCommitQuest
void QuestSystem::handleClientToSeverQuestInfoReq(Message::Ptr& message)
{
    //任务提交请求解包;
    C2GS_QuestSubmitReq xQuestSubmitReq;
    message->unpack(xQuestSubmitReq);

    //向DB发送任务是否存在请求;
    Character* pCharacter = g_charMgr.findCharByUserId(xQuestSubmitReq.userID);
    if (pCharacter == nullptr)
    {
        return;
    }

    QuestIdVec m_questVec = pCharacter->getCharInfo().QuestToClientInfo;
    QuestIdVec::iterator itor = m_questVec.begin();
    QuestIdVec::iterator end = m_questVec.end();
    for (; itor != end; itor++)
    {
        if (*itor == xQuestSubmitReq.nQuestID)
        {
            QuestXmlVo* mQusetXmlVo = getQuestXmlVo(xQuestSubmitReq.nQuestID);
            if (mQusetXmlVo == nullptr)
            {
                std::cout << " this  quest id  can't find  on the xml";
                return;
            }

            {
                // 转化成各个数据库表中的对应类型，方便查询;
                int ChangeType = 0;
                /*
                switch 用来判断 该任务ID对应的 任务类型
                {
                关卡普通，关卡精英，关卡团队，英雄试炼，时光之穴，砖石抽，等。。。。
                此时只是 任务的类型，但是具体各个表中的数据，所对应的类型，可能不是一样的，
                所以，要转化成各个表中的数据--对应的类型

                example：
                任务ID: 10002  任务type: 1   --->>>配置表中这个任务是描述 时光之穴打了多少次

                -----时光之穴数据表中，类型为 3；此时就要把 查询的局部变量type 赋值为3，以方便查询
                case 3：
                {
                SqlType = 3;
                }
                break；
                .
                .

                }
                赋值后的类型，传递给DB 那边，根据对应的类型，去对应的表中查询对应的数据。
                */

                //根据关卡类型的表中去寻找;
                switch (mQusetXmlVo->getQuestType())
                {
                case 1:
                    ChangeType = 1;
                    break;
                case 2:
                    ChangeType = 2;
                    break;
                case 3:
                    ChangeType = 3;
                    break;
                case 4:
                    ChangeType = 4;
                    break;
                case 5:
                    ChangeType = 5;
                    break;
                case 6:
                    ChangeType = 6;
                    break;
                case 7:
                    ChangeType = 7;
                    break;

                default:
                    break;
                }

                QueryMissionInfo(xQuestSubmitReq, ChangeType);
            }
        }
    }

}


//去寻找当前提交的任务信息是否与与关卡中的相匹配;
//QueryMissionInfo
void QuestSystem::QueryMissionInfo(C2GS_QuestSubmitReq xQuestSubmitReq, int n_QuestType)
{
    //查询关卡数据库里面是有有信息与当前提交的任务匹配;

    GS2DS_QuestGetMissonCountInfoReq questGetMissonCountInfoReq;

    questGetMissonCountInfoReq.userID = xQuestSubmitReq.userID;
    questGetMissonCountInfoReq.seq = xQuestSubmitReq.seq;
    questGetMissonCountInfoReq.mQuestID = xQuestSubmitReq.nQuestID;
    questGetMissonCountInfoReq.mQuestType  = n_QuestType;

    Message::Ptr sendMsg(new Message());
    sendMsg->pack(questGetMissonCountInfoReq);
    g_sessionManager.send(g_serverData.getDBProxyMgr()->getDBProxySID(), sendMsg); 
}

//关卡获取的任务是否达到次数条件的信息与当前提交的任务的信息进行比较，如果条件达到就删除该数据，如果没有达到就返回Reuct=1;
void QuestSystem::QuestJudgeInfoAck(Message::Ptr &message)
{
    DS2GS_QuestGetMissonCountInfoAck questGetMissonCountInfoAck;
    message->unpack(questGetMissonCountInfoAck);

    QuestXmlVo* mQusetXmlVos = getQuestXmlVo(questGetMissonCountInfoAck.mQuestID);

    if (questGetMissonCountInfoAck.mQuestCount == mQusetXmlVos->getQuestCoin())
    {
        //判断是删除那个数据元素;
        QuestXmlVo* cQuestXmlVo = getQuestXmlVo(questGetMissonCountInfoAck.mQuestID);

        Character* pCharacter = g_charMgr.findCharByUserId(questGetMissonCountInfoAck.userID);
        if (pCharacter == nullptr)
        {
            return;
        }

        //提交请求任务的限制于关卡中的任务条件相等以后删除该条数据并保存到Save表中;
        QuestIdVec pQuestIdVec = pCharacter->getCharInfo().QuestToClientInfo;
        QuestIdVec::iterator ite = pQuestIdVec.begin();
        QuestIdVec::iterator ender = pQuestIdVec.end();

        for (; ite != ender; ite++)
        {                                                           
            if (*ite == questGetMissonCountInfoAck.mQuestID)
            {
                pQuestIdVec.erase(ite);
                break;
            }
        }
    }
    else
    {
        questGetMissonCountInfoAck.Result = 1;  
    }

    //删除数据表中的任务;
    GS2DS_QuesDeleteSqlInfoReq sQuesDeleteSqlInfoReq;

    sQuesDeleteSqlInfoReq.userID = questGetMissonCountInfoAck.userID;
    sQuesDeleteSqlInfoReq.seq = questGetMissonCountInfoAck.seq;
    sQuesDeleteSqlInfoReq.dQuestID = questGetMissonCountInfoAck.mQuestID;

    Message::Ptr sendMsg(new Message());
    sendMsg->pack(sQuesDeleteSqlInfoReq);
    g_sessionManager.send(g_serverData.getDBProxyMgr()->getDBProxySID(), sendMsg);


}

//完成任务信息的返回;
void QuestSystem::QuestDeleteInfoAck(Message::Ptr &message)
{
    DS2GS_QuesDeleteSqlInfoAck sQuesDeleteSqlInfoAck;
    message->unpack(sQuesDeleteSqlInfoAck);

    // 保存任务数据;
    QuestXmlVo* mQusetXmlVs = getQuestXmlVo(sQuesDeleteSqlInfoAck.dQuestID);
    Character* pCharacter = g_charMgr.findCharByUserId(sQuesDeleteSqlInfoAck.userID);
    if (pCharacter == nullptr)
    {
        return;
    }

    GS2DS_QuestDeltAndSeaveInfoReq sQuestDeltAndSeaveInfoReq;

    sQuestDeltAndSeaveInfoReq.userID = sQuesDeleteSqlInfoAck.userID;
    sQuestDeltAndSeaveInfoReq.seq = sQuesDeleteSqlInfoAck.seq;
    sQuestDeltAndSeaveInfoReq.QuestSeaveDleID = sQuesDeleteSqlInfoAck.dQuestID;
    if (sQuestDeltAndSeaveInfoReq.QuestSeaveDleID == mQusetXmlVs->getQuestID())
    {
    //  sQuestDeltAndSeaveInfoReq.QuestSeaveDleID = /*= mQusetXmlVos->getQuestID() */ sQuesDeleteSqlInfoAck.mQuestID;
        sQuestDeltAndSeaveInfoReq.QuestSeaveDleType = mQusetXmlVs->getQuestType();
        sQuestDeltAndSeaveInfoReq.QuestSeaveDleGroups = mQusetXmlVs->getQuestGroup();
        sQuestDeltAndSeaveInfoReq.QuestSeaveDleCount = mQusetXmlVs->getQuestCoin();
    }

    Message::Ptr sendMsg(new Message());
    sendMsg->pack(sQuestDeltAndSeaveInfoReq);
    g_sessionManager.send(g_serverData.getDBProxyMgr()->getDBProxySID(), sendMsg);


}


//保存到数据库完成的任务信息;
void QuestSystem::QuestSeaveCurrentlyInfo(Message::Ptr &message)
{
    DS2GS_QuestDeltAndSeaveInfoAck sQuestDeltAndSeaveInfoAck;
    message->unpack(sQuestDeltAndSeaveInfoAck);

    GS2C_ListQuestCommitAck mListQuestCommitAck;
    mListQuestCommitAck.userID = sQuestDeltAndSeaveInfoAck.userID;
    mListQuestCommitAck.seq = sQuestDeltAndSeaveInfoAck.seq;
    mListQuestCommitAck.nQuestID = sQuestDeltAndSeaveInfoAck.QuestSeaveDleID;
    mListQuestCommitAck.Result = sQuestDeltAndSeaveInfoAck.sRsuit;

    Message::Ptr sendMsg(new Message());

    Character* pCharacter = g_charMgr.findCharByUserId(mListQuestCommitAck.userID);
    if (pCharacter == nullptr)
    {
        return;
    }

    //打包发送给客户端;
    sendMsg->pack(mListQuestCommitAck);
    g_sessionManager.send(pCharacter->getAgentSeq(), sendMsg);


}

//  读取Xml信息配置表;
void QuestSystem::QuestVoInof()
{
    TiXmlDocument* pXmlDoc = new TiXmlDocument();
    if (pXmlDoc == nullptr)
    {
        return;
    }
    pXmlDoc->LoadFile("./Data/QuestX.xml");
    TiXmlElement* xmlElement = pXmlDoc->RootElement();
    TiXmlElement* pConNtfig = xmlElement->FirstChildElement();
    //循环遍历子节点
    while (pConNtfig)
    {
        QuestXmlVo* pQuestXmlVo = new QuestXmlVo();
        //Task ID;
        int nQuestID = 0;
        pConNtfig->Attribute("QuestID", &nQuestID);
        pQuestXmlVo->setQuestID(nQuestID);

        //Task Type
        int m_nQuestType = 0;
        pConNtfig->Attribute("QuestType", &m_nQuestType);
        pQuestXmlVo->setQuestType(m_nQuestType);

        //Task Group;
        int m_nQuestGroup = 0;
        pConNtfig->Attribute("QuestGroup", &m_nQuestGroup);
        pQuestXmlVo->setQuestGroup(m_nQuestGroup);

        //Task count;
        int m_nQuestCoin = 0;
        pConNtfig->Attribute("Questcoin", &m_nQuestCoin);
        pQuestXmlVo->setQuestCoin(m_nQuestCoin);

        n_TaskInfo.insert(map<int, QuestXmlVo*>::value_type(nQuestID, pQuestXmlVo));

        pConNtfig = pConNtfig->NextSiblingElement();
    }
}

QuestXmlVo* QuestSystem::getQuestXmlVo(int n_QuestId)
{
    map<int, QuestXmlVo*>::iterator iter = n_TaskInfo.find(n_QuestId);
    if (iter != n_TaskInfo.end())
    {
        return iter->second;
    }
    else
    {
        std::cout << "Do't find this MissionId's information" << n_QuestId << endl;
    }

}


APP_NS_END