src/engine/EntityTemplate.h

Go to the documentation of this file.

#ifndef ENTITYTEMPLATE_H
#define ENTITYTEMPLATE_H
#include <vector>
#include <boost/shared_ptr.hpp>
#include "util/Error.h"
#include "VariableTableTemplate.h"
#include "TemplateTable.h"
#include "parser/impcomp/UnresOpSeq.h"
#include "parser/impcomp/OpSeq.h"

namespace green
{
        class EntityTemplate : public VariableTableTemplate
        {
        public:
                EntityTemplate()
                        : VariableTableTemplate()
                {
                        this->AddEntry("x", Variable::FLOAT_VAR, 0.0f);
                        this->AddEntry("y", Variable::FLOAT_VAR, 0.0f);
                        this->AddEntry("xs", Variable::FLOAT_VAR, 0.0f);
                        this->AddEntry("ys", Variable::FLOAT_VAR, 0.0f);
                        this->AddEntry("rot", Variable::FLOAT_VAR, 0.0f);
                }
                
                inline
                void AddBehavior(Key behavior,
                                                                                 ArgListPtr args)
                {
                        CHECK_SHARED(args);
                        mBehaviors.push_back(_listEntry(behavior, args));
                }
                
                inline
                void AddBehavior(const Name& name,
                                                                                 ArgListPtr args)
                {
                        CHECK_SHARED(args);
                        mBehaviors.push_back(_listEntry(name, args));
                }

                inline
                void SetBehaviorKey(size_t behavior, Key key)
                {
                        ERROR_ASSERT(behavior < mBehaviors.size(),
                                                                         "That behavior is not in this template");
                        mBehaviors[behavior].mBehaviorKey = key;
                }
                Key GetBehavior(size_t behavior) const
                {
                        if(behavior > mBehaviors.size())
                                THROW_ERROR("behavior too large");
                        return mBehaviors[behavior].mBehaviorKey;
                }
                
                inline
                const Name& GetBehaviorName(size_t behavior)
                {
                        ERROR_ASSERT(behavior < mBehaviors.size(),
                                                                         "that behavior is not in this template");
                        return mBehaviors[behavior].mBehaviorName;
                }

                ArgListPtr GetBehaviorArgs(size_t behavior) const
                {
                        if(behavior > mBehaviors.size())
                                THROW_ERROR("behavior too large");
                        return mBehaviors[behavior].mArg;
                }

                inline
                size_t GetNumBehaviors() const
                {
                        return mBehaviors.size();
                }


                void addInitCode(UnresOpSeqPtr uInitCodeIn) {
                        CHECK_SHARED(uInitCodeIn);
                        unresInitCode = uInitCodeIn;
                }

                UnresOpSeqPtr getInitCode() {
                        CHECK_SHARED(unresInitCode);
                        return unresInitCode;
                }


                void addResolvedInit(VariableTableTemplatePtr argList,OpSeqPtr resdCode) {
                        CHECK_SHARED(argList);
                        CHECK_SHARED(resdCode);
                        
                        if (initCode.get() != 0) return;
                        initCode = resdCode;

                        //yes.. I'm ashamed but resolveOpSeq takes a VarTableTemplate
                        //and that is just hard hard to change... soooo.... yea...
                        InitFormatPtr initFormat(new InitFormat());
                        for (size_t i=0;i<argList->GetNumEntries();++i)
                                initFormat->push_back(InitArgFormat(i,argList->GetEntry(i).mType));
                }


                virtual void Print(std::ostream& os)
                {
                        VariableTableTemplate::Print(os);
                        os << std::endl;
                        os << "Behaviors:" << std::endl;
                        for(size_t i = 0; i < mBehaviors.size(); i++)
                        {
                                os << " Key: " << mBehaviors[i].mBehaviorKey;
                                os << " Name: " << mBehaviors[i].mBehaviorName;
                                os << " ArgList: ";
                                
                                CHECK_SHARED(mBehaviors[i].mArg);
                                for(size_t j = 0; j < mBehaviors[i].mArg->size(); j++)
                                        os << mBehaviors[i].mArg->at(j) << " ";
                                os << std::endl;
                        }

                        os << "CODE:" << std::endl;
                        if(unresInitCode.get())
                                unresInitCode->dumpScreen();
                        if(initCode.get())
                                initCode->dumpScreen();
                }
                
        protected:

                class _listEntry
                {
                public:
                        _listEntry(Key behavior, ArgListPtr arg) :
                                        mBehaviorKey(behavior), mArg(arg) {}
                        _listEntry(const Name& name, ArgListPtr arg) :
                                        mBehaviorKey(0), mBehaviorName(name), mArg(arg) {}
                        
                        Key mBehaviorKey;
                        Name mBehaviorName;
                        ArgListPtr mArg;
                };

                std::vector<_listEntry> mBehaviors;

                //unresolved and resolved code stuff, TODO:delete UnresOpSeqs
                UnresOpSeqPtr unresInitCode;
                OpSeqPtr initCode;
        };
        typedef boost::shared_ptr<EntityTemplate> EntityTemplatePtr;
        #define ENTITY_TEMPLATE_CAST(x) boost::dynamic_pointer_cast<EntityTemplate>(x)
}

#endif

---