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