src/engine/GRunApplication.h

Go to the documentation of this file.

#ifndef GRUNAPPLICATION_H
#define GRUNAPPLICATION_H

#include <iostream>
#include <sstream>

#include <boost/shared_ptr.hpp>
#include "util/Error.h"
#include "backend/Application.h"
#include "backend/RenderSystem.h"
#include "System.h"
#include "EntityTemplateTable.h"
#include "BehaviorTemplateTable.h"
#include "MessageTemplateTable.h"
#include "MessagePool.h"
#include "EntityPool.h"
#include "util/Timer.h"
#include "LibraryMessages.h"
#include "LibraryBehaviors.h"
#include "LibraryEntities.h"
#include "parser/ProjFileParser.h"

namespace green
{
        class GRunApplication : public Application
        {
                protected:
                        
                        EntityTemplateTablePtr mEntityTemplates;
                        BehaviorTemplateTablePtr mBehaviorTemplates;
                        MessageTemplateTablePtr mMessageTemplates;
                        
                        EntityPoolPtr mEntityPool;
                        MessagePoolPtr mMsgPool;
                        
                        SystemPtr mSys;
                        
                        Key mDefaultEntityType;
                        Key mKeyEventMsgType;
                        Key mAlwaysMsgType;
                        
                        ID mFirstEntity;
                        
                        Timer mTimer;
                        
                        void _InitDefaultEntity()
                        {
                                // Add the behavior to the template table
                                Key bVarKey = mBehaviorTemplates->AddEntry("move", MoveBehavior::CreateTemplate());
                                
                                Interpreter::SetMoveBehaviorKey(bVarKey);
                                
                                // create the default entity template
                                EntityTemplatePtr defaultEntity = DefaultEntity::CreateTemplate();
                                
                                CHECK_SHARED(defaultEntity);
                                
                                // Create an ArgList to use
                                ArgListPtr oneArg(new ArgList());
                                
                                // Now add a behavior to the template
                                defaultEntity->AddBehavior("move", oneArg);
                                
                                // Set the key for the behavior we added
                                defaultEntity->SetBehaviorKey(0, bVarKey);
                                
                                // add the default entity type to the entity template table
                                mDefaultEntityType = mEntityTemplates->AddEntry("default", defaultEntity);
                                
                                // Print the BehaviorTemplateTable
                                std::cout << "--- BehaviorTemplateTable ---" << std::endl;
                                mBehaviorTemplates->Print(std::cout);
                                
                                // Print the template table now
                                std::cout << std::endl << "--- EntityTemplateTable ---" << std::endl;
                                mEntityTemplates->Print(std::cout);
                        }
                        
                public:
                        GRunApplication() :
                                Application(),
                                mEntityTemplates(new EntityTemplateTable()),
                                mBehaviorTemplates(new BehaviorTemplateTable()),
                                mMessageTemplates(new MessageTemplateTable()),
                                mEntityPool(new EntityPool()),
                                mMsgPool(new MessagePool()),
                                mSys(new System())
                        {
                                mEntityTemplates->SetBehaviorTemplateTable(mBehaviorTemplates);
                        }
                        
                        virtual void Init()
                        {
                                this->_InitDefaultEntity();

                                // Add the KeyEventMsg template to mMessageTemplates
                                MessageTemplatePtr keyEventMsgTemplate(KeyEventMsg::CreateTemplate());
                                CHECK_SHARED(keyEventMsgTemplate);
                                
                                mKeyEventMsgType = mMessageTemplates->AddEntry("keyEvent", keyEventMsgTemplate);
                                
                                MessageTemplatePtr alwaysMsgTemplate(AlwaysMsg::CreateTemplate());
                                CHECK_SHARED(alwaysMsgTemplate);
                                
                                mAlwaysMsgType = mMessageTemplates->AddEntry("always", alwaysMsgTemplate);
                                
                                std::cerr << "## Message templates ##" << std::endl;
                                mMessageTemplates->Print(std::cerr);
                                
                                // Create an ArgList to use
                                ArgListPtr oneArg(new ArgList());
                                
                                // Now instantiate an entity with that ArgList
                                EntityInstancePtr firstEntity(
                                                        mEntityTemplates->Instantiate(mDefaultEntityType, oneArg));
                                
                                CHECK_SHARED(firstEntity);
                                
                                mEntityPool->AddInstance(firstEntity);
                                
                                mSys->SetMessagePool(mMsgPool);

                                std::string fileName("testproj.gep");
                                ProjFileParser::parseProject(fileName,mSys,mBehaviorTemplates,
                                                     mEntityTemplates,mMessageTemplates,mEntityPool);

                        }
                        
                        virtual void display()
                        {
                                ERROR_ASSERT(mRenderSystem.get(), "render system not valid");
                                mRenderSystem->StartFrame();
                                static bool firstFrame = true;
                                if(firstFrame)
                                {
                                        mTimer.StartTiming();
                                        firstFrame = false;
                                }
                                else
                                        mTimer.StopTiming();
                                
                                // Start by checking if new entities need to be spawned from last frame
                                for(size_t i = 0; i < mSys->mEntities.size(); i++)
                                {
                                        EntityInstancePtr newInstance(
                                                        mEntityTemplates->Instantiate(mSys->mEntities[i].mType, 
                                                                                                                                                                                mSys->mEntities[i].mArgs));
                                        CHECK_SHARED(newInstance);
                                        mEntityPool->AddInstance(newInstance);
                                }
                                
                                // now check if any new messages need to be processed from last frame
                                for(size_t i = 0; i < mSys->mMessages.size(); i++)
                                {
                                        std::stringstream err;
                                        err << "mSys->mMessages[" << i << "] is ";
                                        err << mSys->mMessages[i].mType << "which is not < ";
                                        err << mMessageTemplates->GetNumEntries();
                                        ERROR_ASSERT(mSys->mMessages[i].mType < mMessageTemplates->GetNumEntries(), err.str());
                                        MessageInstancePtr newMessage(MESSAGE_INSTANCE_CAST(
                                                        mMessageTemplates->Instantiate(mSys->mMessages[i].mType,
                                                                                                                                                                                mSys->mMessages[i].mArgs)));
                                        CHECK_SHARED(newMessage);
                                        mMsgPool->AddMessage(mSys->mMessages[i].mTarget, newMessage);
                                }
                                
                                // Add the default message that gets sent every frame
                                MessageInstancePtr defaultMsg = 
                                                AlwaysMsg::Instantiate(mAlwaysMsgType, mDefaultEntityType, mMessageTemplates);
                                
                                ERROR_ASSERT(defaultMsg->GetTemplate() < mMessageTemplates->GetNumEntries(), "defaultMsg too high");
                                mMsgPool->AddMessage(mDefaultEntityType, defaultMsg);
                                
                                // now clear the System
                                mSys->Clear();
                                mSys->SetTimer(mTimer);
                                
                                // Run behaviors on entities
                                mEntityPool->ProcessEntities(mSys,mBehaviorTemplates);
                                
                                // Draw all the entities
                                mEntityPool->DrawEntities(mRenderSystem);
                                
                                // Clear out the MessagePool for next frame
                                mMsgPool->Clear();
                                
                                mTimer.StartTiming();
                                mRenderSystem->FinishFrame();
                        }

                        virtual void keyboard(unsigned char ch, int x, int y) 
                        {
                                std::cout << "key " << ch << " down" << std::endl;
                                KeyEventMsg keyMsg(ch, 1);
                                
                                MessageInstancePtr newMsg(keyMsg.Instantiate(mKeyEventMsgType, mMessageTemplates));
                                CHECK_SHARED(newMsg);
                                
                                std::stringstream err;
                                err << "newMsg->GetTemplate() is ";
                                err << newMsg->GetTemplate() << "which is not < ";
                                err << mMessageTemplates->GetNumEntries();
                                ERROR_ASSERT(newMsg->GetTemplate() < mMessageTemplates->GetNumEntries(), err.str());
                                
                                mMsgPool->AddMessage(mKeyEventMsgType, newMsg);
                        }
                
                        virtual void keyboard_up(unsigned char ch, int x, int y)
                        {
                                std::cout << "key " << ch << " up" << std::endl;
                                KeyEventMsg keyMsg(ch, 0);
                                MessageInstancePtr newMsg(keyMsg.Instantiate(mKeyEventMsgType, mMessageTemplates));
                                
                                CHECK_SHARED(newMsg);
                                std::stringstream err;
                                err << "newMsg->GetTemplate() is ";
                                err << newMsg->GetTemplate() << "which is not < ";
                                err << mMessageTemplates->GetNumEntries();
                                ERROR_ASSERT(newMsg->GetTemplate() < mMessageTemplates->GetNumEntries(), err.str());
                                
                                mMsgPool->AddMessage(mKeyEventMsgType, newMsg);
                        }
                        
        };
        typedef boost::shared_ptr<GRunApplication> GRunApplicationPtr;
}
#endif

---