cocos2dx游戏任务系统开发

UI.HPP

#ifndef __QUESTUI_HEADER__
#define __QUESTUI_HEADER__

#include <typedef.hpp>
#include <cocos-base.h>
#include <TableView.h>
#include "ScrollView.h"
#include "WidgetProtocol.h"
#include "cocos-ext.h"
#include "cocos-widget.h"
#include "QuestProxy.hpp"
#include <list>
#include <vector>


CLIENT_NS_BEGIN

USING_NS_CC;

enum QuestUiBtn
{
    tagCloseQuest,//退出按钮枚举;
    tagQuestGreyBtn,//添加灰阶枚举;

    tagQuestTestBtn             //任务添加单元格按钮枚举;

};


class QuestUi :
    public CSceneExtension
{
public:
    CREATE_SCENE_FUNC(QuestUi)

    QuestUi();

    virtual ~QuestUi();

    virtual void onLoadResources();

    virtual void onLoadResourcesCompleted();

    virtual void onLoadScene();

    virtual void onEnterScene();

    void onClickQuest(Ref* pSender);

    void onSeverQuest(int Rid);

    CWidgetWindow* m_pWindow;



    //将任务过来的信息ID容器拷贝出来;
    std::vector<i32>::iterator beg;

    std::vector<string>QuestNameVe;
    std::vector<string>::iterator nameBegin;
private:



    // 任务背景层;
    CC_SYNTHESIZE_READONLY(CCSprite*,m_pQuestBg,QuestBg);
    // 任务退出Button；
    CC_SYNTHESIZE_READONLY(cocoswidget::CButton*,m_pCloseQuest,CloseQuest);
    // 任务标题显示;
    CC_SYNTHESIZE_READONLY(CCSprite*,m_pQuestTitle,QuestTitle);
    // 添加灰阶背景;
    CC_SYNTHESIZE_READONLY(cocoswidget::CButton*,m_pQuestGreyBgBtn,QuestGreyBgBtn);
    // 循环任务Button;
    CC_SYNTHESIZE_READONLY(cocoswidget::CTableView*,m_pQuestView,QuestView);

    CC_SYNTHESIZE_READONLY(cocoswidget::CButton*,m_pQuesButton,QuestCellButton);

    // 添加任务名字信息;
    CC_SYNTHESIZE_READONLY(Label*,m_pTitleName,TitleName);

    QuestProxy* m_pQuestPro;


private:

    Ref* gridpageviewDataSource(Ref* pConvertCell,unsigned int idx);
};

#define g_missionDalog QuestUi::getInstance();

APP_NS_END

#endif __QUESTUI_HEADER__

CPP

#include "QuestUi.hpp"
#include <ScreenUtil.hpp>
#include <CMisc.hpp>
#include <Facade.hpp>
#include <Language.hpp>
#include "QuestMediator.hpp"
#include <XmlConfig.hpp>

CLIENT_NS_BEGIN

using namespace cocoswidget;

QuestUi::QuestUi()// :
//m_pQuestPro(nullptr)
{
    setCachable(true);
    setAutoRemoveUnusedTexture(true);

    m_pQuestPro = (QuestProxy*)g_facade.retrieveProxy("QuestProxy");


    // 拷贝容器;
    //ButSize = m_pQuestPro->ClientQuestInfo;
    beg = m_pQuestPro->butsize.begin();

    //在构造里面不能用，这个样会导致先进入这个然后在获取所对应的值;
    //nameBegin = QuestNameVe.begin();
}

QuestUi::~QuestUi()
{
}

//  UI资源添加;
void QuestUi::onLoadResources()
{

    addImageAsync("QuestUi/DailyQuestBg.jpg");
    addImageAsync("QuestUi/DailyQuestBg_alpha_mask.png");
    addImageAsync("QuestUi/task_window_title_bg.jpg");
    addImageAsync("QuestUi/task_window_title_bg_alpha_mask.png");
    addImageAsync("QuestUi/close.jpg");
    addImageAsync("QuestUi/close_alpha_mask.png");
    addImageAsync("QuestUi/greyBg_1.png");

}

void QuestUi::onLoadResourcesCompleted()
{

}

//  各种UI按钮界面显示展示;
void QuestUi::onLoadScene()
{
    //  添加灰阶背景;
    m_pQuestGreyBgBtn = cocoswidget::CButton::create();
    getQuestGreyBgBtn()->setNormalImage("QuestUi/greyBg_2.png");
    getQuestGreyBgBtn()->setAnchorPoint(ccp(0,0));
    getQuestGreyBgBtn()->setPosition(ccp(0,0));
    this->addChild(getQuestGreyBgBtn());
    this->setTag(tagQuestGreyBtn);

    //  添加背景图层;
    m_pQuestBg = CCSprite::create("QuestUi/QuestBg_1.png");
    getQuestBg()->setAnchorPoint(ccp(0,0));
    getQuestBg()->setPosition(ccp(177,90));
    this->addChild(getQuestBg());

    //  任务退出按钮的添加;
    Texture2D* pCloseNormal = getNewTexture("QuestUi/close.jpg","QuestUi/close_alpha_mask.png");
    m_pCloseQuest = cocoswidget::CButton::create();
    getCloseQuest()->setNormalTexture(pCloseNormal);
    getCloseQuest()->setAnchorPoint(ccp(0,0));
    getCloseQuest()->setPosition(ccp(810,490));
    getCloseQuest()->setTag(tagCloseQuest);
    this->addChild(getCloseQuest());

    //  任务标题显示;
    Texture2D* pQuestTitle = getNewTexture("QuestUi/task_window_title_bg.jpg","QuestUi/task_window_title_bg_alpha_mask.png");
    m_pQuestTitle = CCSprite::createWithTexture(pQuestTitle);
    getQuestTitle()->setAnchorPoint(ccp(0,0));
    getQuestTitle()->setPosition(ccp(137,520));
    this->addChild(getQuestTitle());

    //添加WINDOW 按键;
    m_pWindow = CWidgetWindow::create();
    m_pWindow->setMultiTouchEnabled(true);
    m_pWindow->setAnchorPoint(ccp(0,0));
    m_pWindow->setPosition(ccp(0,0));
    this->addChild(m_pWindow);



    //任务滑动层
    m_pQuestView = CTableView::create(
        Size(729,415),Size(600,135),0,//shu
        this,ccw_datasource_adapter_selector(QuestUi::gridpageviewDataSource));
    m_pQuestView->setDirection(eScrollViewDirectionVertical);
    m_pQuestView->setAutoRelocate(true);
    m_pQuestView->setAnchorPoint(ccp(0,0));
    m_pQuestView->setPosition(Vec2(205,115));
    m_pWindow->addChild(m_pQuestView);

    beg = m_pQuestPro->butsize.begin();
    nameBegin = QuestNameVe.begin();

}



void QuestUi::onEnterScene()
{
    g_facade.sendNotification(FRAME_MESSAGE_ENTER_QUEST_UI);
}

//  任务按钮循环创建;   
Ref* QuestUi::gridpageviewDataSource(Ref* pConvertView,unsigned int idx)
{
    CTableViewCell* pCell = (CTableViewCell*)pConvertView;

    CButton* pButton = nullptr;

    if (!pCell)
    {
        pCell = new CGridPageViewCell();
        pCell->autorelease();

        //  添加
        pButton = CButton::createWith9Sprite(Size(600,125),"QuestUi/questFrameBg.png","QuestUi/task_window_title_bg_alpha_mask.png");
        pButton->setOnClickListener(this,ccw_click_selector(QuestMediator::onClickBtn));
        pButton->setAnchorPoint(ccp(0,0));
        pButton->setTag(tagQuestTestBtn);
        pButton->setPosition(ccp(0,0));
        pCell->addChild(pButton);   

        pButton->setUserTag(*beg);

        //名字显示在 单元格上;
        m_pTitleName = CLabel::create();
        getTitleName()->setString(*nameBegin);
        getTitleName()->setColor(Color3B(0,0));
        getTitleName()->setPosition(Vec2(205,115));
        pButton->addChild(getTitleName());

        if (beg != m_pQuestPro->butsize.end())
        {
            beg++;
            nameBegin++;
        }

    }
    else
    {

        pButton = (CButton*)pCell->getChildByTag(tagQuestTestBtn);

    }


    return pCell;
}



 void QuestUi::onClickQuest(Ref* pSender)
 {
 }



APP_NS_END

QuestMediator.hpp
上面的两个是UI展示部分也就是说能让玩家看到效果的演示而已

QuestMediator.hpp这里是UI部分的控制相当于说这里是大脑而UI是你的肢体

#include <typedef.hpp>
#include <Mediator.hpp>
#include <QuestUi.hpp>
#include <MainMediator.hpp>
#include <FortuneMediator.hpp>
#include <QuestProxy.hpp>
#include <stdio.h>

CLIENT_NS_BEGIN

USING_NS_CC;

class QuestMediator :
    public Mediator
{
public:
    QuestMediator();
    ~QuestMediator();

    virtual void onRegisterNotification();

    virtual void handleNotification(Notification* pNotification);

    virtual void update();

    virtual std::string getMediatorName(){ return "QuestMediator"; }

    void onClickQuestInof();


private:
    CC_SYNTHESIZE_READONLY(QuestUi*,m_pQuestUi,QuestUi);
    CC_SYNTHESIZE_READONLY(QuestProxy*,m_pQuestProxy,QuestProxy);
    CC_SYNTHESIZE_READONLY(cocoswidget::CLabel*,TitleName);

    void onClickBtn(CCObject* pObject);

};

APP_NS_END

CPP

#include "QuestMediator.hpp"
#include <Facade.hpp>
#include <MultiMediator.hpp>

CLIENT_NS_BEGIN

QuestMediator::QuestMediator() :
m_pQuestUi(nullptr),m_pQuestProxy(nullptr)
{
    REGISTER_SCENE_FUNC(QuestUi);
    m_pQuestProxy = (QuestProxy*)g_facade.retrieveProxy("QuestProxy");
}

QuestMediator::~QuestMediator()
{
}

void QuestMediator::onRegisterNotification()
{
    m_xFrameMessageVec.push_back(FRAME_MESSAGE_SHOW_QUEST_UI);

    m_xFrameMessageVec.push_back(FRAME_MESSAGE_ENTER_QUEST_UI);

    m_xFrameMessageVec.push_back(FRAME_MESSAGE_EXIT_QUEST_UI);

}


void QuestMediator::handleNotification(Notification* pNotification)
{
    if (NULL == pNotification)
    {
        return;
    }

    switch (pNotification->m_xMessage)
    {
    //  点击以后进入任务界面;
    case FRAME_MESSAGE_SHOW_QUEST_UI:
    {
        m_pQuestUi = (QuestUi*)LoadScene("QuestUi");
        CSceneManager::getInstance()->runUIScene(m_pQuestUi);

        getQuestProxy()->clientQuestInfo = g_character.getQuestSQLInfovc();

        //拷贝上线时候的任务;
        getQuestProxy()->butsize = getQuestProxy()->clientQuestInfo;

        vector<int>::iterator itor = getQuestProxy()->butsize.begin();
        vector<int>::iterator end = getQuestProxy()->butsize.end();
        for (;itor!=end; itor++)
        {
            QuestXmlVo* sQ = getQuestProxy()->getQuestInof(*itor);
            getQuestUi()->QuestNameVe.push_back(sQ->getQuestName());
        }

        //广播当前任务信息;
        //g_facade.sendNotification()
    }
        break;

    case FRAME_MESSAGE_ENTER_QUEST_UI:
    {
        if (getQuestProxy() == nullptr)
        {
            return;
        }

        // 上线是反馈回来的长度;
        m_pQuestUi->getQuestView()->setCountOfCell(m_pQuestProxy->butsize.size());
        getQuestUi()->getQuestView()->reloadData();
        getQuestUi()->getCloseQuest()->setOnClickListener(this,ccw_click_selector(QuestMediator::onClickBtn));
    }
        break;


    case  FRAME_MESSAGE_EXIT_QUEST_UI:
    {

        CSceneManager::getInstance()->getRunningScene()->setModalable(false);
        CSceneManager::getInstance()->popUIScene(m_pQuestUi);

        FortuneMediator* pFortuneMediator = (FortuneMediator*)g_facade.retrieveMediator("FortuneMediator");
        if (nullptr == pFortuneMediator)
        {
            return;
        }
        pFortuneMediator->getFortuneUi()->setModalable(false);

        //  返回主场景;
        MultiMediator* pMultiMediator = (MultiMediator*)g_facade.retrieveMediator("MultiMediator");
        if (nullptr == pMultiMediator)
        {
            return;
        }
        pMultiMediator->getMultiUi()->setModalable(false);
    }
        break;


    }
}

//  状态的更新;
void QuestMediator::update()
{
    /*if (NULL == pNotification)
    {
        return;
    }

    switch (pNotification->m_xMessage)
    {*/
        /*
        //任务数据更新以后;
        case FRAME_MESSAGE_CHANGE_QUEST_UI:
        {
        //任务数据更新以后;
        if (getQuestProxy() == nullptr)
        {
        return;
        }

        // 上线是反馈回来的长度;
        m_pQuestUi->getQuestView()->setCountOfCell(m_pQuestProxy->butsize.size());
        getQuestUi()->getQuestView()->reloadData();
        getQuestUi()->getCloseQuest()->setOnClickListener(this,ccw_click_selector(QuestMediator::onClickBtn));
        }
        break;*/
//  }

}

void QuestMediator::onClickBtn(CCObject* pObject)
{

    auto pButton = (cocoswidget::CButton*)pObject;
    if (nullptr == pButton)
    {
        return;
    }

    switch (pButton->getTag())
    {
    case tagQuestTestBtn:
    {

        //任务ID;
        auto tag = pButton->getUserTag();

        QuestProxy* pQuestProxy = (QuestProxy*)g_facade.retrieveProxy("QuestProxy");

        if (nullptr == pQuestProxy)
        {
            return;
        }
        pQuestProxy->handleQuestcommpReq(tag);
    }
        break;

    case tagCloseQuest:
    {
                          CCLog("tagCloseQuest");
                          g_facade.sendNotification(FRAME_MESSAGE_EXIT_QUEST_UI);
    }
        break;
    default:
        break;
    }
}
APP_NS_END

UI到服务端的通信也就是传到服务端的信息，比如我是什么任务请求提交 或者完成 或者是否有这个任务等;传到服务端那边的只能是ID
如果你加入string huo这char 这些那么你就会增加通信量减缓消息的接受速度等;

#ifndef __QUEST_PROXY_HEADER__
#define __QUEST_PROXY_HEADER__

#include <typedef.hpp>
#include <Proxy.hpp>
#include <QuestXmlVo.hpp>
#include "Character.hpp"
CLIENT_NS_BEGIN

enum MyEnum
{

};

class QuestProxy : public Proxy
{
public:
    QuestProxy();
    ~QuestProxy();

    virtual void onInitilize();

    virtual void onRegisterMessage();

    virtual std::string getProxyName(){ return "QuestProxy"; }

    void handleQuestcommpReq(int ID);

    //接收请求结果;
    void SeverQuestAgentTokenAck(Message::Ptr &message);

    // Xml信息加载;
    QuestXmlVo* getQuestInof(int QuestID);

    //服务端过来的信息ID容器;
    typedef std::vector<i32> ClientQuestInfo;
    ClientQuestInfo clientQuestInfo;

    //将任务过来的信息ID ClientQusetVo 容器拷贝出来;
    typedef std::vector<i32> ButSize;
    ButSize butsize;


    std::vector<QuestXmlVo*> XmlVo;

    // 返回字典长度
    int getDirLength();

private:
    // 加载信息;
    void loadQuestInfo();

    CC_SYNTHESIZE_READONLY(Character*,m_pCharacter,Character);

private:
    CC_SYNTHESIZE(CCDictionary*,m_pQuestInof,QuestInof);

};

APP_NS_END

#endif // !__QUEST_PROXY_HEADER__

CPP

#include "QuestProxy.hpp"
#include <tinyxml2/tinyxml2.h>
#include "GameServer/Quest.hpp"
#include <Alert.hpp>
#include <Facade.hpp>
#include "QuestMediator.hpp"
#include <NetDelegate.hpp>


CLIENT_NS_BEGIN

QuestProxy::QuestProxy() :
m_pCharacter(nullptr)
{
    m_pQuestInof = CCDictionary::create();
    m_pQuestInof->retain();

    m_pCharacter = (Character*)g_facade.retrieveProxy("Character");
}


QuestProxy::~QuestProxy()
{
}


void QuestProxy::onInitilize()
{
    loadQuestInfo();
// getDirLength();
}

void QuestProxy::onRegisterMessage()
{   
    DEFREG_MESSAGE(ID_GS2C_ListQuestCommitAck,QuestProxy,SeverQuestAgentTokenAck)
}

//任务请求客户端向服务端发送消息;
void QuestProxy::handleQuestcommpReq(int ID)
{


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

    questSubmitReq.nQuestID = ID;

    sendMsg->pack(questSubmitReq);
    g_netDelegate.send(sendMsg);

}

//接收请求结果;
void QuestProxy::SeverQuestAgentTokenAck(Message::Ptr &message)
{


    GS2C_ListQuestCommitAck sListQuestCommitAck;
    message->unpack(sListQuestCommitAck);

    std::vector<int>::iterator ite = butsize.begin();
    std::vector<int>::iterator ender = butsize.end();

    for (; ite != ender; ite++)
    {
        if (*ite == sListQuestCommitAck.nQuestID)
        {
            butsize.erase(ite);
            break;
        }
    }
        g_facade.sendNotification(FRAME_MESSAGE_ENTER_QUEST_UI);
    //QuestMediator* pQuestMediator = (QuestMediator*)g_facade->retrieveMediator(FRAME_MESSAGE_CHANGE_QUEST_UI);
    //pQuestMediator->;//->setMailInfoMap(mailInfoMap); */

    //g_facade.sendNotification(FRAME_MESSAGE_CHANGE_QUEST_UI);
}


QuestXmlVo* QuestProxy::getQuestInof(int QuestID)
{
    DictElement* pQuestElement = nullptr;

    CCDICT_FOREACH(m_pQuestInof,pQuestElement)
    {
        auto KeyQuestID = pQuestElement->getIntKey();

        if (KeyQuestID == QuestID)
        {
            QuestXmlVo* QuestsInfo = (QuestXmlVo*)pQuestElement->getObject();
            return QuestsInfo;
        }
    }


    std::vector<int>::iterator ite = butsize.begin();
    std::vector<int>::iterator ender = butsize.end();
    for (; ite != ender; ite++)
    {
        QuestXmlVo* mVo = getQuestInof(*ite);
        XmlVo.push_back(mVo);
    }


}

//XML 客户端的配置读取
void QuestProxy::loadQuestInfo()
{
    ssize_t bufferSize = 0;

    unsigned char* pBuffer = CCFileUtils::sharedFileUtils()->getFileData("QuestX.xml","r",&bufferSize);

    if (NULL == pBuffer)
    { 
        return;
    }

    tinyxml2::XMLDocument* pXml = new tinyxml2::XMLDocument();

    pXml->Parse((const char*)pBuffer);

    tinyxml2::XMLElement* pNode = pXml->RootElement()->FirstChildElement();

    QuestXmlVo* pQuestXmlVo = nullptr;
    while (pNode)
    {
        pQuestXmlVo = new QuestXmlVo();
        // 任务ID;
        pQuestXmlVo->setQuestID(pNode->IntAttribute("QuestID"));

        // 任务名字;
        pQuestXmlVo->setQuestName(pNode->Attribute("QuestName"));

        // 任务资源;
        pQuestXmlVo->setQuestImageID(pNode->Attribute("QuestImageID"));

        // 任务线;
        pQuestXmlVo->setQuestGroup(pNode->IntAttribute("QuestGroup"));

        // 前置任务;
        pQuestXmlVo->setQuestRelate(pNode->IntAttribute("QuestRelate"));

        // 任务解锁等级;
        pQuestXmlVo->setQuestNlockGrade(pNode->IntAttribute("QuestNlockGrade"));

        // 任务类型;
        pQuestXmlVo->setQuestType(pNode->IntAttribute("QuestType"));

        // 任务目标参数1;
        pQuestXmlVo->setQuestTargetParam1(pNode->IntAttribute("QuestTargetParam1"));

        // 任务目标参数2;
        pQuestXmlVo->setQuestTargetParam2(pNode->IntAttribute("QuestTargetParam2"));

        // 任务目标参数3;
        pQuestXmlVo->setQuestTargetParam3(pNode->IntAttribute("QuestTargetParam3"));

        // 任务加权;
        pQuestXmlVo->setQuestWeight(pNode->IntAttribute("QuestWeight"));

        // 任务任务描述;
        pQuestXmlVo->setQuestDescription(pNode->Attribute("QuestDescription"));

        // 任务金币奖励;
        pQuestXmlVo->setQuestcoin(pNode->IntAttribute("QuestCoin"));

        // 任务水晶奖励;
        pQuestXmlVo->setQuestCrystal(pNode->Attribute("QuestCrystal"));

        // 任务经验奖励;
        pQuestXmlVo->setQuetsExp(pNode->IntAttribute("QuetsExp"));

        // 任务其他奖励类型;
        pQuestXmlVo->setQuestRewardType(pNode->Attribute("QuestRewardType"));

        // 任务其他奖励;
        pQuestXmlVo->setQuestReward(pNode->IntAttribute("QuestReward"));

        // 任务说明;
        pQuestXmlVo->setQuestRemark(pNode->Attribute("QuestRemark"));

        // 任务动作;
        pQuestXmlVo->setQuestACtion(pNode->Attribute("QuestACtion"));

        // 任务目标;
        pQuestXmlVo->setQuestDestination(pNode->IntAttribute("QuestDestination"));



        pQuestXmlVo->autorelease();

        m_pQuestInof->setObject(pQuestXmlVo,pQuestXmlVo->getQuestID());

        pNode = pNode->NextSiblingElement();
    }
}

APP_NS_END