利用工厂模式实现怪物系统

古城微笑少年丶 2022-08-21 02:12 52阅读 0赞

### 利用工厂模式可以有效的降低类与类的藕合性，增强代码的可重用性，工厂模式主要通过虚函数的原理进行。 ###

### 当基类指针指向一个子类对象，通过这个指针调用子类和基类同名成员函数的时候，基类声明为虚函数「子类不写也可以」就会调子类的这个函数，不声明就会调用基类的。 ###

### 虚析构函数的作用 ###

我们知道，用C++开发的时候，用来做基类的类的析构函数一般都是虚函数。可是，为什么要这样做呢？下面用一个小例子来说明：    
        有下面的两个类：
    
    class ClxBase
    {
    public:
        ClxBase() {};
        virtual ~ClxBase() {};
    
        virtual void DoSomething() { cout << "Do something in class ClxBase!" << endl; };
    };
    
    class ClxDerived : public ClxBase
    {
    public:
        ClxDerived() {};
        ~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; }; 
    
        void DoSomething() { cout << "Do something in class ClxDerived!" << endl; };
    };
        代码
    
    ClxBase *pTest = new ClxDerived;
    pTest->DoSomething();
    delete pTest;
        的输出结果是：
    
    Do something in class ClxDerived!
    Output from the destructor of class ClxDerived!
        这个很简单，非常好理解。
        但是，如果把类ClxBase析构函数前的virtual去掉，那输出结果就是下面的样子了：
    
    Do something in class ClxDerived!
        也就是说，类ClxDerived的析构函数根本没有被调用！一般情况下类的析构函数里面都是释放内存资源，而析构函数不被调用的话就会造成内存泄漏。我想所有的C++程序员都知道这样的危险性。当然，如果在析构函数中做了其他工作的话，那你的所有努力也都是白费力气。
        所以，文章开头的那个问题的答案就是－－这样做是为了当用一个基类的指针删除一个派生类的对象时，派生类的析构函数会被调用。
        当然，并不是要把所有类的析构函数都写成虚函数。因为当类里面有虚函数的时候，编译器会给类添加一个虚函数表，里面来存放虚函数指针，这样就会增加类的存储空间。所以，只有当一个类被用来作为基类的时候，才把析构函数写成虚函数

### 工厂模式实现 ###

## 工厂类 ##

#ifndef __Item_H__
    #define __Item_H__
    
    #include "Common.h"
    class Mario;
    
    // 基类，和工厂类
    // 分割模块（让模块之间搞内聚，低耦合）
    // 多态（虚函数）
    class Item : public CCSprite
    {
    public:
        enum ItemType{IT_mushroom, IT_tortoise, IT_flower, IT_mushroomReward, IT_mushroomAddLife, IT_flagpoint};
        // Item* item;     delete item;
        virtual ~Item();
    
        // 所有道具都需要调用的初始化工作
        bool init()
        {
            CCSprite::init();
            setZOrder(100);
            // 为道具提供动力
            scheduleUpdate();
            return true;
        }
    
        Mario* _mario;
        static CCArray* _itemReward;
        static Item* _Flag;
    
        // 工厂接口
        static Item* create(CCDictionary* dict);
    
        // 对象的虚接口
        virtual void move(float dt) {}
        virtual void collision() {}
        virtual void wakeup(){}
    
        void update(float dt)
        {
            move(dt);
            collision();
        }
    
        ////////////////////////////// 公共辅助函数
        void setPositionByProperty(CCDictionary* dict)
        {
            const CCString* x = dict->valueForKey("x");
            const CCString* y = dict->valueForKey("y");
            setPosition(ccp(x->intValue(), y->intValue() - 16));
            setAnchorPoint(ccp(0, 0));
        }
    
        CCTMXTiledMap* getMap()
        {
            return (CCTMXTiledMap*)getParent();
        }
    
        bool isLeftInWindow()
        {
        //  CCPoint ptInMap = getPosition();
            CCRect rcItem = boundingBox();
            CCPoint ptInMap = ccp(rcItem.getMinX(), rcItem.getMinY());
    
            CCTMXTiledMap* map = getMap();
            CCPoint ptInWorld = map->convertToWorldSpace(ptInMap);
            if (ptInWorld.x <= winSize.width)
            {
                return true;
            }
    
            return false;
        }
    
        bool isFarAwayFromMario();
    
        ItemType _type;
    };
    
    #if 0
    class ItemFactroy
    {
    public:
        Item* createItem(Item::ItemType it)
        {
            return Item::create(it);
        }
    };
    #endif
    
    #endif

### 工厂接口实现 ###

#include "Item.h"
    #include "ItemMushroom.h"
    #include "Mario.h"
    #include "ItemTortoise.h"
    Item::~Item()
    {
    
    }
    Item* Item::create(CCDictionary* dict)
    {
        const CCString *type=dict->valueForKey("type");
        if (type->m_sString=="mushroom")
        {
            return ItemMushroom::create(dict);
        }else if (type->m_sString == "tortoise")
            return ItemTortoise::create(dict);
    
        return NULL;
    
    }
    
    bool Item::isOutOfWindow()
    {
        CCRect rcItem=this->boundingBox();
        CCRect rcMario=_mario->boundingBox();
        if (rcMario.getMinX()-rcItem.getMaxX()>winSize.width)
        {
            return true;
        }
    
        return false;
    }

### 使用工厂模式，就不用在游戏中加入各个怪物的头文件，只需要包含Item.h就可以了，降低了怪物层与游戏层的藕合性，增强了内聚性，同时也增强了代码的重用性。 ###