commandFactory.h

Go to the documentation of this file.

/* 
 * File:   commandFactory.h
 * Author: chris
 *
 * Created on September 16, 2013, 10:25 AM
 */

#ifndef COMMANDFACTORY_H
#define COMMANDFACTORY_H
#include "command.h"
#include "enums.h"
#include "commandHelp.h"
#include <deque>
#include "engine.h"

namespace FastEcslent {
    //class Entity;

    enum RequiredTargetType
{
    None,
    TargetPosition,
    TargetEntity,
    Either,
    Both
};

    class CommandFactory {
    public:
        CommandFactory(RequiredTargetType requiredTargetType, std::string previewMeshName = "", EntityType targetEntityType = NENTITYTYPES) : requiredTarget(requiredTargetType),previewMeshName(previewMeshName),targetEntityType(targetEntityType) {} ;
        CommandFactory(const CommandFactory& orig);
        virtual ~CommandFactory();
        virtual std::deque<Command*> MakeCommand(Entity* owner, std::pair<int, Ogre::Vector3 > mouseTargets) = 0;
        RequiredTargetType requiredTarget;
        EntityType targetEntityType;
        std::string previewMeshName;
    protected:
        //Engine   *engine;

    };

    class BuildFactory : public CommandFactory {
    public:

        BuildFactory(EntityType spawnEnt) :CommandFactory(None), spawnEnt(spawnEnt) {
        };
        BuildFactory(const CommandFactory& orig);

        virtual ~BuildFactory() {
        };

        virtual std::deque<Command*> MakeCommand(Entity* owner, std::pair<int, Ogre::Vector3 > mouseTargets) {
            std::deque<Command*> newCommands;
            newCommands.push_back(new BuildCommand(owner, spawnEnt, FastEcslent::ConstructCommand));
            return newCommands;
        }
    private:
        EntityType spawnEnt; 
    };
    
    class BuildStructureFactory : public CommandFactory {
    public:

        BuildStructureFactory(EntityType spawnEnt,std::string previewMeshName = "", RequiredTargetType requiredTargetType = TargetPosition,EntityType targetEntityType = NENTITYTYPES) :CommandFactory(requiredTargetType,previewMeshName,targetEntityType), spawnEnt(spawnEnt) {
        };
        BuildStructureFactory(const CommandFactory& orig);

        virtual ~BuildStructureFactory() {
        };

        virtual std::deque<Command*>  MakeCommand(Entity* owner, std::pair<int, Ogre::Vector3 > mouseTargets);
    private:
        EntityType spawnEnt; 
    };
    
    class MoveFactory : public CommandFactory {
    public:

        MoveFactory() :CommandFactory(TargetPosition) {
        };
        MoveFactory(const CommandFactory& orig);

        virtual ~MoveFactory() {
        };

        virtual std::deque<Command*> MakeCommand(Entity* owner, std::pair<int, Ogre::Vector3 > mouseTargets) {
            std::deque<Command*> newCommands;
            newCommands.push_back(createMoveForEnt(owner, mouseTargets.second));
            return newCommands;
        }
    private:
        

    };
}

#endif  /* COMMANDFACTORY_H */

---