Changeset 27 for nrEngine


Ignore:
Timestamp:
03/30/07 23:52:31 (12 years ago)
Author:
art
Message:

nrScript: using of subscripts is now possible

Location:
nrEngine
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/include/IScript.h

    r24 r27  
    6767 * does provide this functionality. But at now there is no other way to do this. 
    6868 **/ 
    69   
     69 
    7070namespace nrEngine{ 
    71          
     71 
    7272 
    7373        //! Script interface for any kind of script languages 
     
    9191        * Passed parameters will be automaticaly removed from the waiting list as 
    9292        * soon as the function from the script will be called. 
    93         *  
     93        * 
    9494        * @see IResource, ITask 
    9595        * \ingroup script 
     
    104104                         **/ 
    105105                        NR_FORCEINLINE const std::string& getContent() const { return mContent; } 
    106                          
     106 
    107107                        /** 
    108108                        * Load a script from string. The given string should contain 
     
    114114                        **/ 
    115115                        virtual Result loadFromString(const std::string& str) = 0; 
    116          
     116 
    117117                        /** 
    118118                        * Get short description of the last error. 
    119119                        **/ 
    120120                        std::string popLastError(); 
    121          
     121 
    122122                        /** 
    123123                         * Execute the script. The script will be executed completely, before 
     
    128128                         *                      once. If you specify false, so run() will be called in each 
    129129                         *                      kernel cycle. 
    130                          *  
     130                         * 
    131131                         * NOTE: If you want to execute script immidiately, use forceExecute() instead 
    132132                         **/ 
     
    164164                         **/ 
    165165                        ScriptResult call(const std::string& funcName); 
    166   
     166 
    167167                        /** 
    168168                         * User application can also specify certain arguments for functions 
     
    190190                         **/ 
    191191                        uint32 setArguments(const std::string& funcName, const ArgumentList& args); 
    192                          
     192 
    193193                        /** 
    194194                         * Derived class should use this function to pop the first parameter 
     
    241241                         **/ 
    242242                        void pushErrorMessage(const std::string& msg); 
    243                          
     243 
    244244                        /** 
    245245                         * Initialize the script interface 
     
    253253                         **/ 
    254254                        virtual ~IScript(); 
    255                          
     255 
    256256                        /** 
    257257                         * Run one step from the script. This method will be automaticaly 
     
    264264                         **/ 
    265265                        Result onStartTask(); 
    266                          
     266 
    267267                        //! Here we store the whole script as a string 
    268268                        std::string mContent; 
    269                                                                          
     269 
    270270                        /** 
    271271                         * Bypass the IResource::unloadRes() function, so that derived 
     
    273273                         **/ 
    274274                        virtual Result unloadRes() {return OK;} 
    275                          
    276                         //! Check if script should only run once  
     275 
     276                        //! Check if script should only run once 
    277277                        bool shouldRunOnce() const { return mbRunOnce; } 
    278                          
     278 
    279279                        //! Should the script run only once (no loop) 
    280280                        void setRunOnce(bool b) { mbRunOnce = b; } 
    281                           
    282                         /** 
    283                          * This method will be called to check from base class to  
    284                          * check if run completes. If derived class returns false,  
    285                          * so script will be removed from the kernel  
     281 
     282                        /** 
     283                         * This method will be called to check from base class to 
     284                         * check if run completes. If derived class returns false, 
     285                         * so script will be removed from the kernel 
    286286                         **/ 
    287287                        virtual bool hasCommands() = 0; 
    288                          
     288 
    289289                        /** 
    290290                         * This method will be called if a script is gonna be executed. 
     
    292292                         **/ 
    293293                        virtual void onStartScript() {}; 
    294                          
     294 
     295                        /** 
     296                         * Call this method to manually specify, that a script is 
     297                         * loaded and can be executed. The method should be called 
     298                         * from loadFromString() method by derived classes 
     299                         **/ 
     300                        void notifyLoaded(); 
     301 
    295302                private: 
    296303 
    297                         //! Should this script run once  
     304                        //! Should this script run once 
    298305                        bool mbRunOnce; 
    299                          
     306 
    300307                        //! Store here error messages 
    301308                        std::list<std::string> mErrorMsg; 
    302                          
     309 
    303310                        typedef std::map<std::string, ArgumentList>             ArgumentDatabase; 
    304                          
     311 
    305312                        //! Notify if the resource was reloaded 
    306313                        void notifyResReloaded(); 
     
    311318        }; 
    312319 
    313          
     320 
    314321        //! Empty script object that just do nothing(idle). 
    315322        /** 
     
    319326        class _NRExport EmptyScript : public IScript{ 
    320327        public: 
    321          
     328 
    322329                //! Constructor does not call anything 
    323                 EmptyScript(); 
    324                  
     330                EmptyScript(const std::string& typeName); 
     331 
    325332                //! Release used memory 
    326333                ~EmptyScript(); 
     
    335342                bool hasCommands() { return false; } 
    336343        }; 
    337          
     344 
    338345}; 
    339346 
  • nrEngine/include/Result.h

    r19 r27  
    254254                //! No empty resource was created before 
    255255                RES_NO_EMPTY_RES_FOUND          = RES_ERROR | (1 << 13), 
    256                  
     256 
    257257 
    258258                //------------------------------------------------------------------------------ 
     
    297297                //! Wrong parameter value given 
    298298                SCRIPT_WRONG_PARAMETER_VALUE = SCRIPT_ERROR | (1 << 4), 
    299                  
     299 
     300                //! Script is already running 
     301                SCRIPT_ALREADY_RUNNING = SCRIPT_ERROR | (1 << 5), 
     302 
    300303                //------------------------------------------------------------------------------ 
    301304                //! Generic event management error 
     
    328331                //! Given actor is not valid 
    329332                EVENT_NO_VALID_ACTOR = EVENT_ERROR | (1 << 8), 
    330                  
     333 
    331334                //------------------------------------------------------------------------------ 
    332335                //! Generic group for properties errors 
     
    338341                //! Wrong property type, so cannot cast 
    339342                PROPERTY_WRONG_TYPE = PROPERTY_ERROR | (1 << 1), 
    340                  
     343 
    341344                //------------------------------------------------------------------------------ 
    342345                //! This are general engine layer errors 
  • nrEngine/include/Script.h

    r25 r27  
    4141         *  - one command per one frame (if not other specified) 
    4242         *  - commands can be bound to a certain time (execute command at this time) 
    43          *  - time values could be either relative to the previous command or absolute(= relative to the start time of the script) 
     43         *  - time values are always relative to the start time of the script 
    4444         *  - nontimed commands are executed sequentially 
    4545         *  - timed commands are executed quasi parallel to the nontimed 
     
    5353         *  1.693 | run script/script2.tml // execute script script/script2.tml after the time reaches 1.693 
    5454         * 
     55         * Scripts could include subscripts. Subscripts are defined between 
     56         * {} - brackets. The string between this brackets is used as a scipts 
     57         * if it was used in an explicit file. So the string is parsed 
     58         * as a script and runs also parallel to the parent script. For timed 
     59         * and non-timed commands the same restrictions are used as in non-subscripts. 
     60         * Subscripts could define new subscripts. 
     61         * 
    5562         * NOTE: 
    5663         *      - We represent each script as a task, so the scripts are running in parallel 
    5764         *      - This type of script can run stepwise which is default behaviour. Specify it in 
    5865         *              another way if you want to run the script completely in one frame. 
    59          *  
     66         * 
    6067         * @see IScript 
    6168         * \ingroup script 
     
    8794                         *              update the clock or the kernel. This is not allowed by tasks, 
    8895                         *              it means tasks can not update them self only kernel can do this. 
    89                          *  
     96                         * 
    9097                         *              So if you call execute() so only sequential commands will be 
    9198                         *              executed! 
     
    112119                         **/ 
    113120                        NR_FORCEINLINE bool isRunStepwise() const { return bRunStepwise; } 
    114                          
     121 
    115122                private: 
    116123 
     
    120127                        //! Script was started 
    121128                        void onStartScript(); 
    122                          
     129 
    123130                        //! Derived from IScript 
    124131                        Result run(); 
    125                          
     132 
    126133                        //!  Parse the given string as nrScript language 
    127134                        Result parse(const std::string&); 
    128135 
     136                        //! Remove all comments and empty lines from the script 
     137                        std::string cleanScript(const std::string&); 
     138 
     139                        //! Parse subscripts and return non-sub-script back 
     140                        std::string parseSubscripts(const std::string&); 
     141 
    129142                        //! Set certain parameter from the script 
    130143                        bool setParameter(const std::string& param); 
     
    141154                        //! Reset the command lists (if return false, so the task is removed from kernel) 
    142155                        bool reset(); 
    143                          
     156 
    144157                        //! Script is valid 
    145158                        bool mValid; 
     
    148161                        int32 mLastLine; 
    149162 
     163                        //! Subscripts which belongs to this one 
     164                        std::vector<ResourcePtr<IScript> > mSubscripts; 
     165 
    150166                        //! Current running time of the script 
    151167                        //float32 mRunningTime; 
    152                          
     168 
    153169                        //! Time script have to stop after this duration 
    154170                        float32 mRunningTimeLength; 
    155                          
    156                         //! Time when script started  
     171 
     172                        //! Time when script started 
    157173                        float32 mStopTime; 
    158                          
     174 
    159175                        //! Run teh script stepwise 
    160176                        bool bRunStepwise; 
    161                          
     177 
    162178                        //! Each command has this type 
    163179                        typedef struct _cmd{ 
     
    205221                        //! Current time of the script 
    206222                        float32 mTime; 
    207                          
     223 
    208224                        //! Run only one step from the script 
    209225                        Result step(); 
    210                          
     226 
    211227        }; 
    212228 
  • nrEngine/src/IScript.cpp

    r24 r27  
    3030 
    3131        //-------------------------------------------------------------------- 
     32        void IScript::notifyLoaded() 
     33        { 
     34                markResLoaded(); 
     35        } 
     36 
     37        //-------------------------------------------------------------------- 
    3238        Result IScript::onStartTask() 
    3339        { 
    3440                // notice derived classes about starting 
    3541                onStartScript(); 
    36                  
     42 
    3743                return OK; 
    3844        } 
     
    4349                // set running counter parameter 
    4450                mbRunOnce = runOnce; 
    45                  
     51 
     52                // if task is already running, so do not do anything 
     53                if (getTaskState() == TASK_RUNNING) return SCRIPT_ALREADY_RUNNING; 
     54 
    4655                // add the task to the kernel 
    4756                // also kernel is not allowed to remove this object, because 
     
    5766        { 
    5867                mbRunOnce = runOnce; 
    59                  
     68 
    6069                // we only run the script nothing more 
    6170                if (runOnce) return run(); 
     
    6473                return execute(runOnce); 
    6574        } 
    66          
     75 
    6776        //-------------------------------------------------------------------- 
    6877        Result IScript::updateTask() 
    6978        { 
    70                 // run the script  
     79                // run the script 
    7180                Result ret = run(); 
    7281 
     
    8897        IScript::~IScript() 
    8998        { 
    90          
     99 
    91100        } 
    92101 
     
    95104        { 
    96105                mbRunOnce = true; 
     106                setTaskName(std::string("Script_") + name); 
    97107        } 
    98108 
     
    152162                std::string type, value; 
    153163                while (popArgument(funcName, type, value) > 0){} 
    154                  
     164 
    155165                // return ok 
    156166                return OK; 
     
    163173                std::string msg = mErrorMsg.front(); 
    164174                mErrorMsg.pop_front(); 
    165                 return msg;              
    166         } 
    167          
     175                return msg; 
     176        } 
     177 
    168178        //---------------------------------------------------------------------------------- 
    169179        void IScript::pushErrorMessage(const std::string& sh) 
     
    177187        //---------------------------------------------------------------------------------- 
    178188        //---------------------------------------------------------------------------------- 
    179         EmptyScript::EmptyScript() : IScript("EmptyScript") 
     189        EmptyScript::EmptyScript(const std::string& typeName) : IScript(typeName + "Empty") 
    180190        { 
    181191 
  • nrEngine/src/Kernel.cpp

    r17 r27  
    7575                                _taskStart(*it); 
    7676                } 
    77                  
     77 
    7878                // resetup to the beginning 
    7979                it = taskList.begin(); 
    80                  
     80 
    8181                // we go always from teh first element in the list, because it is 
    8282                // the system root task 
     
    8484                while (_loopGetNextTask(taskList.begin(), it, 0) == OK){ 
    8585                        SharedPtr<ITask>& t=(*it); 
    86                          
     86 
    8787                        if (t && !t->_taskCanKill){ 
    88                                  
     88 
    8989                                // if the task is running 
    9090                                if (t->getTaskState() == TASK_RUNNING){ 
     
    9494                                        sprintf(name, "%s::update", t->getTaskName()); 
    9595                                        _nrEngineProfile(name); 
    96                                          
     96 
    9797                                        t->updateTask(); 
    9898 
     
    105105                } 
    106106                _loopEndCycle(); 
    107                  
     107 
    108108                PipelineIterator thisIt; 
    109109                TaskId tempID; 
     
    114114                        SharedPtr<ITask> &t=(*it); 
    115115                        bool killed = false; 
    116                          
     116 
    117117                        // kill task if we need this 
    118118                        if(t && t->_taskCanKill){ 
     
    137137                // thread behaviour. 
    138138                IThread::yield(); 
    139                  
     139 
    140140                // return good result 
    141141                return OK; 
     
    148148                if (bInitializedRoot) return; 
    149149                bInitializedRoot = true; 
    150                  
     150 
    151151                // get iterator through our std::list 
    152152                PipelineIterator it; 
     
    181181        } 
    182182        */ 
    183          
     183 
    184184        //------------------------------------------------------------------------- 
    185185        Result Kernel::_taskStart(SharedPtr<ITask>& task) 
    186186        { 
    187                  
     187 
    188188                // no task given, so return error 
    189189                if (!task) 
     
    197197                        task->setTaskState(TASK_RUNNING); 
    198198                        task->onStartTask(); 
    199                          
     199 
    200200                }else{ 
    201201 
    202202                        // check for the task states 
    203                         if (task->getTaskState() == TASK_STOPPED){ 
     203                        if (task->getTaskState() == TASK_STOPPED) 
     204                        { 
    204205                                task->setTaskState(TASK_RUNNING); 
    205206                                task->onStartTask(); 
    206  
    207207                        }else if (task->getTaskState() == TASK_PAUSED){ 
    208208                                return ResumeTask(task->getTaskID()); 
     
    210210 
    211211                } 
    212                                  
     212 
    213213                // send a message about current task state 
    214214                if (bSendEvents){ 
     
    216216                        Engine::sEventManager()->emitSystem(msg); 
    217217                } 
    218                  
     218 
    219219                // OK 
    220220                return OK; 
     
    231231                        // check if the task is not a thread 
    232232                        if (task->getTaskProperty() & TASK_IS_THREAD){ 
    233                                  
     233 
    234234                                SharedPtr<IThread> thread = boost::dynamic_pointer_cast<IThread, ITask>(task); 
    235235                                NR_Log(Log::LOG_KERNEL, "Stop thread/task \"%s\" (id=%d)", task->getTaskName(), task->getTaskID()); 
     
    245245                        return UNKNOWN_ERROR; 
    246246                } 
    247                  
     247 
    248248                // send a message about current task state 
    249249                if (bSendEvents){ 
     
    307307 
    308308                        t->_taskOrder = order; 
    309                          
     309 
    310310                        // check whenever such task already exists 
    311311                        std::list< SharedPtr<ITask> >::iterator it; 
    312312                        for (it = taskList.begin(); it != taskList.end(); it++){ 
    313313                                if ((*it) == t || (*it)->getTaskID() == t->getTaskID() || strcmp((*it)->getTaskName(),t->getTaskName())==0){ 
    314                                         NR_Log(Log::LOG_KERNEL, "Found same task in task std::list !"); 
     314                                        NR_Log(Log::LOG_KERNEL, "Cannot add task \"%s\" because same task was already added!", t->getTaskName()); 
    315315                                        return 0; 
    316316                                } 
     
    354354                        } 
    355355 
    356                         // add into the list  
     356                        // add into the list 
    357357                        taskList.insert (it,t); 
    358358 
     
    375375 
    376376                if (id == 0) return OK; 
    377                  
    378                 try{  
     377 
     378                try{ 
    379379 
    380380                        NR_Log(Log::LOG_KERNEL, "Remove task with id=%d", id); 
     
    779779 
    780780                t->_taskGraphColor = 1; 
    781                  
     781 
    782782                // now check if the task has got childrens 
    783783                if (t->_taskDependencies.size() > 0) 
     
    803803                                } 
    804804                        }*/ 
    805                          
    806                         // iterate through all dependencies and check them  
     805 
     806                        // iterate through all dependencies and check them 
    807807                        std::list<SharedPtr<ITask> >::iterator jt = t->_taskDependencies.begin(); 
    808808                        for (; jt != t->_taskDependencies.end(); jt ++) 
     
    820820                                        } 
    821821                                } 
    822                          
    823                         } 
    824                          
     822 
     823                        } 
     824 
    825825                // we do not have childs, so this is a leaf node 
    826826                } 
  • nrEngine/src/ResourceLoader.cpp

    r25 r27  
    2222 
    2323namespace nrEngine{ 
    24          
     24 
    2525        //---------------------------------------------------------------------------------- 
    2626        IResourceLoader::IResourceLoader(const std::string& name) : mName(name) 
     
    5151                        return SharedPtr<IResource>(); 
    5252                } 
    53                  
     53 
    5454                bool typeFound = false; 
    5555                std::string type; 
    56                  
     56 
    5757                // we search for the type if no type is specified 
    5858                if (resourceType.length() == 0){ 
    5959                        NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceLoader \"%s\" try to find according resource type by filename \"%s\"", mName.c_str(), fileName.c_str(), fileName.c_str()); 
    60                          
     60 
    6161                        // detect the file type by reading out it's last characters 
    6262                        for (int32 i = fileName.length()-1; i >= 0 && !typeFound; i--){ 
     
    6767                        } 
    6868                        if (!typeFound) type = ""; 
    69                          
     69 
    7070                        // check whenever the given file name is supported by the resource 
    7171                        if (typeFound && !supportFileType(type)) 
     
    8181                        } 
    8282                } 
    83                  
     83 
    8484                // ok the name is supported, so now create a instance 
    8585                SharedPtr<IResource> res; 
     
    9090                } 
    9191                if (res.get() == NULL) return res; 
    92                  
     92 
    9393                // setup some data on resource 
    9494                res->mResFileName = fileName; 
     
    115115        { 
    116116                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceLoader: Create resource of type %s", resourceType.c_str()); 
    117                  
     117 
    118118                // first check if this type of resource is supported 
    119119                if (!supportResourceType(resourceType)) 
     
    131131                // now check if we have to create an empty resource for this type 
    132132                SharedPtr<IResource> empty = Engine::sResourceManager()->getEmpty(resourceType); 
    133                                  
     133 
    134134                // if not created before, so create it and register by the manager 
    135                 if (empty == NULL){ 
     135                if (empty == NULL) 
     136                { 
    136137                        empty.reset( createEmptyResource(resourceType), IResource::_deleter() ); 
    137138                        empty->mResGroup = "_Empty_Resource_Group_"; 
     
    142143                        empty->setResourceType(resourceType); 
    143144                } 
    144                  
     145 
    145146                // set the resource in the manager 
    146147                Engine::sResourceManager()->setEmpty(resourceType, empty); 
    147                  
     148 
    148149                // setup default resource data 
    149150                res->setResourceType(resourceType); 
     
    151152                res->mResIsEmpty = false; 
    152153                res->mResLoader = getSharedPtrFromThis(); 
    153                  
     154 
    154155                // now set this resource in the list of handled resource objects 
    155156                mHandledResources.push_back(res); 
    156                  
     157 
    157158                // ok now return the instance 
    158159                return res; 
     
    183184                r->mResName = name; 
    184185                r->mResGroup = group; 
    185                  
     186 
    186187                // now let manager know about the new resource 
    187188                Engine::sResourceManager()->notifyCreated(r.get()); 
     
    198199                // call the implementation of the unloader 
    199200                if (resource->mResIsLoaded){ 
    200                          
     201 
    201202                        Result ret = unloadResourceImpl(resource.get()); 
    202203                        if (ret != OK) return ret; 
    203                  
     204 
    204205                        // now mark the resource that it has been unloaded 
    205206                        resource->mResIsLoaded = false; 
    206                          
     207 
    207208                        // notify the resource manager about unloading the resource 
    208209                        Engine::sResourceManager()->notifyUnloaded(resource.get()); 
    209210                } 
    210                  
     211 
    211212                return OK; 
    212213        } 
     
    220221                        return OK; 
    221222                } 
    222                  
     223 
    223224                // unload the resource 
    224225                unload(resource); 
    225                  
     226 
    226227                // call the implementation of the unloader 
    227228                if (resource->mResIsLoaded == false) 
    228229                { 
    229                          
     230 
    230231                        Result ret = reloadResourceImpl(resource.get()); 
    231232                        if (ret != OK) return ret; 
    232                  
     233 
    233234                        // now mark the resource that it has been unloaded 
    234235                        resource->mResIsLoaded = true; 
    235                          
     236 
    236237                        // notify the resource manager about unloading the resource 
    237238                        Engine::sResourceManager()->notifyLoaded(resource.get()); 
     
    256257                // unload 
    257258                unload(resource); 
    258                  
     259 
    259260                // notify to remove the resource 
    260261                notifyRemoveResource(resource); 
     
    270271        { 
    271272                ResourceList::iterator resit = std::find(mHandledResources.begin(), mHandledResources.end(), res); 
    272                  
     273 
    273274                // check if such resource is loaded 
    274275                if (resit != mHandledResources.end() ){ 
    275                  
     276 
    276277                        // ok remove the resource from the handled resources 
    277278                        mHandledResources.erase(resit); 
     
    313314                // now notify the resource manager, that a new resource was loaded 
    314315                //Engine::sResourceManager()->notifyLoaded(res); 
    315                  
    316                 return OK; 
    317         } 
    318          
     316 
     317                return OK; 
     318        } 
     319 
    319320        //---------------------------------------------------------------------------------- 
    320321        bool IResourceLoader::supportResourceType(const std::string& resourceType) const { 
     
    336337                return false; 
    337338        } 
    338          
     339 
    339340}; 
    340341 
  • nrEngine/src/ResourceManager.cpp

    r25 r27  
    3131                std::string type; 
    3232                if (args.size() == 5 ) type = args[4]; 
    33                  
     33 
    3434                // load a resource with the given name in a group from a file 
    3535                if (Engine::sResourceManager()->loadResource(args[1], args[2], args[3], type).isNull()) 
     
    3939                        return ScriptResult(std::string(msg)); 
    4040                } 
    41                  
     41 
    4242                return ScriptResult(); 
    4343        } 
     
    5858                        return ScriptResult(std::string(msg)); 
    5959                } 
    60                  
     60 
    6161                return ScriptResult(); 
    6262        } 
     
    6969                Engine::sScriptEngine()->add("loadResource", scriptLoadResource); 
    7070                Engine::sScriptEngine()->add("unloadResource", scriptUnloadResource); 
    71                  
     71 
    7272        } 
    7373 
     
    7979                Engine::sScriptEngine()->del("loadResource"); 
    8080                Engine::sScriptEngine()->del("unloadResource"); 
    81                  
     81 
    8282                // unload all resources 
    8383                removeAllRes(); 
     
    197197 
    198198                NR_Log(Log::LOG_ENGINE, "ResourceManager: Remove loader %s", name.c_str()); 
    199                  
     199 
    200200                mLoader.erase(name); 
    201201 
     
    207207 
    208208                if (fileType.length() == 0) return ResourceLoader(); 
    209                  
     209 
    210210                // scan through all loaders and ask them if they do support this kind of file type 
    211211                loader_map::const_iterator it; 
     
    255255        { 
    256256                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceManager: Create resource %s of type %s in group %s", name.c_str(), resourceType.c_str(), group.c_str()); 
    257                  
     257 
    258258                // check if such a resource already exists 
    259259                IResourcePtr pRes = getByName(name); 
     
    262262                        return pRes; 
    263263                } 
    264                  
     264 
    265265                // Get appropriate loader/creator 
    266266                ResourceLoader creator = getLoaderByResource(resourceType); 
     
    272272                // now call the loader to create a resource 
    273273                SharedPtr<IResource> res (creator->create(name, group, resourceType, params)); 
    274                 if (res.get() == NULL){ 
     274                if (res.get() == NULL) 
     275                { 
    275276                        NR_Log(Log::LOG_ENGINE, "ResourceManager: Can not create a resource %s of %s type", name.c_str(), resourceType.c_str()); 
    276277                        return IResourcePtr(); 
     
    280281                SharedPtr<ResourceHolder>& holder = *getHolderByName(name); 
    281282                NR_ASSERT(holder != NULL && "Holder must be valid here!"); 
    282                  
     283 
    283284                return IResourcePtr(holder); 
    284285        } 
    285          
     286 
    286287 
    287288        //---------------------------------------------------------------------------------- 
     
    330331                SharedPtr<IResource> res = loader->load(name, group, fileName, resourceType, params); 
    331332                if (res == NULL) return IResourcePtr(); 
    332                  
     333 
    333334                // get the holder for this resource, it must be there 
    334335                SharedPtr<ResourceHolder>& holder = *getHolderByName(name); 
    335336                NR_ASSERT(holder.get() != NULL && "Holder must be valid here!"); 
    336                  
    337                 return IResourcePtr(holder);     
    338         } 
    339          
     337 
     338                return IResourcePtr(holder); 
     339        } 
     340 
    340341        //---------------------------------------------------------------------------------- 
    341342        Result ResourceManager::unload(const ::std::string& name){ 
     
    635636        } 
    636637*/ 
    637          
     638 
    638639        //---------------------------------------------------------------------------------- 
    639640        Result ResourceManager::lockPure(const ::std::string& name){ 
     
    796797                // check if such a group exists 
    797798                res_grp_map::const_iterator it = mResourceGroup.find(name); 
    798                  
    799                 // return the empty list  
     799 
     800                // return the empty list 
    800801                if (it == mResourceGroup.end()) 
    801802                        return mEmptyResourceGroupHandleList; 
    802                          
    803                 // return the group to this name  
     803 
     804                // return the group to this name 
    804805                return it->second; 
    805806        } 
    806          
     807 
    807808        //---------------------------------------------------------------------------------- 
    808809        SharedPtr<IResource> ResourceManager::getEmpty(const std::string& type) 
     
    816817                return it->second; 
    817818        } 
    818                  
     819 
    819820        //---------------------------------------------------------------------------------- 
    820821        void ResourceManager::setEmpty(const std::string& type, SharedPtr<IResource> empty) 
     
    822823                // check if empty is valid 
    823824                if (empty == NULL) return; 
    824                  
     825 
    825826                // setup some default data on it 
    826827                mEmptyResource[type] = empty; 
     
    847848                const ResourceHandle& handle = res->getResHandle(); 
    848849                const std::string& type = res->getResType(); 
    849                   
     850 
    850851                // get according empty resource object and give exception if no such exists 
    851852                IResource* empty = getEmpty(type).get(); 
    852                 if (empty == NULL){ 
     853                if (empty == NULL) 
     854                { 
    853855                        char msg[128]; 
    854856                        sprintf(msg, "There was no empty resource created for the type %s", type.c_str()); 
    855857                        NR_EXCEPT(RES_NO_EMPTY_RES_FOUND, std::string(msg), "ResourceManager::notifyLoaded()"); 
    856858                } 
    857                  
     859 
    858860                // get name of the resource and create a holder for this 
    859861                SharedPtr<ResourceHolder> holder(new ResourceHolder(res, empty)); 
     
    864866                mResourceName[name] = handle; 
    865867 
    866                 //printf("LOADED: %s\n", holder->getResource()->getResName().c_str());           
     868                //printf("LOADED: %s\n", holder->getResource()->getResName().c_str()); 
    867869        } 
    868870 
     
    926928                mResource.erase(handle); 
    927929        } 
    928          
     930 
    929931}; 
    930932 
  • nrEngine/src/Script.cpp

    r25 r27  
    2020#include "Log.h" 
    2121#include "Kernel.h" 
     22#include <boost/algorithm/string/trim.hpp> 
    2223 
    2324namespace nrEngine { 
     
    4445        Result Script::loadFromString(const std::string& str) 
    4546        { 
    46                 // set task name as resource name  
     47                // set task name as resource name 
    4748                setTaskName(getResName() + "_ScriptTask"); 
    48                  
     49 
    4950                // setup content 
    5051                mContent = str; 
    51                 return parse(mContent); 
    52         } 
    53  
    54         //------------------------------------------------------------------------------ 
    55         Result Script::parse(const std::string& script){ 
    56  
     52 
     53                // parse it 
     54                Result ret = parse(mContent); 
     55                if (ret == OK) notifyLoaded(); 
     56 
     57                return ret; 
     58        } 
     59 
     60        //------------------------------------------------------------------------------ 
     61        std::string Script::cleanScript(const std::string& script) 
     62        { 
     63                // check the lenght of the script 
    5764                std::stringstream str(script); 
    58                 if (script.length() == 0 || !str.good()) return OK; 
     65                if (script.length() == 0 || !str.good()) return script; 
     66                std::string resultScript; 
    5967 
    6068                // get linewise 
    61                 char buf[1024]; 
     69                char buf[2048]; 
    6270                std::string buffer; 
    6371                std::string::size_type pos; 
    6472                std::string line; 
    65                 int32 l = 0; 
    66  
    67                 while (!str.eof()){ 
    68                         l ++; 
    69                         mLastLine = l; 
    70  
    71                         str.getline(buf, 1024); 
     73 
     74                // for the whole stream do following 
     75                while (!str.eof()) 
     76                { 
     77                        // get line 
     78                        str.getline(buf, 2048); 
    7279                        buffer = std::string(buf); 
    7380 
    74                         // get the line without comments 
     81                        // remove comments 
    7582                        pos = buffer.find("//"); 
    7683                        if (pos == std::string::npos) 
     
    7986                                line = buffer.substr(0, pos); 
    8087 
     88                        // trim the line 
     89                        boost::algorithm::trim(line); 
     90 
    8191                        // if the line is empty, so get the next one 
    8292                        if (line.length() == 0) continue; 
    8393 
     94                        // if we are here, so we do not have any comments or empty lines 
     95                        resultScript += line; 
     96                        if (!str.eof()) resultScript += std::string("\n"); 
     97                } 
     98 
     99                return resultScript; 
     100        } 
     101 
     102        //------------------------------------------------------------------------------ 
     103        std::string Script::parseSubscripts(const std::string& script) 
     104        { 
     105                // vars 
     106                int depth = 0, count = 0; 
     107 
     108                // for parsing we are using stack-algorithm 
     109                std::vector<std::string> stack; 
     110                stack.push_back(std::string("")); 
     111                std::string* top = &stack[stack.size()-1]; 
     112 
     113                // go through the given script 
     114                for (unsigned int i=0; i < script.length(); i++) 
     115                { 
     116                        top = &(stack[stack.size()-1]); 
     117                        if (script.at(i) == '{') 
     118                        { 
     119                                depth ++; 
     120                                stack.push_back(std::string("")); 
     121                        } 
     122                        else if (script.at(i) == '}') 
     123                        { 
     124                                depth --; 
     125                                count ++; 
     126 
     127                                if (depth >= 0) 
     128                                { 
     129                                        // create name for the new subscript 
     130                                        std::stringstream subscriptName; 
     131                                        subscriptName << getResName() << std::string("_sub_") << count << std::string("_") << depth; 
     132 
     133                                        // current top element is a new script, so create it 
     134                                        ResourcePtr<IScript> scr = Engine::sResourceManager()->createResource(subscriptName.str(), getResName(), "Script"); 
     135 
     136                                        // if script could be created, so fill it and store, to execute later 
     137                                        if (scr.isNull()) 
     138                                        { 
     139                                                NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script (%s): Subscript could not be created. Maybe no proper loader exists. Script will not run.\n", getResName().c_str()); 
     140                                                return std::string(""); 
     141                                        }else{ 
     142                                                scr.lockPure(); 
     143                                                        scr->loadFromString(*top); 
     144                                                scr.unlockPure(); 
     145                                                mSubscripts.push_back(scr); 
     146                                        } 
     147 
     148                                        // remove top element 
     149                                        stack.pop_back(); 
     150                                } 
     151                        }else{ 
     152                                *top += script.at(i); 
     153                        } 
     154                } 
     155 
     156 
     157                // check if closing brackets were complete 
     158                if (depth != 0) 
     159                { 
     160                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "Script (%s): Subscript-brackets were not used properly. Depth is %d, must be 0. Script could not run as expected!", getResName().c_str(), depth); 
     161                } 
     162 
     163                // return mainscript back 
     164                return cleanScript(stack[0]); 
     165        } 
     166 
     167        //------------------------------------------------------------------------------ 
     168        Result Script::parse(const std::string& script) 
     169        { 
     170                // remove all non-commands from the script 
     171                // check for subscripts 
     172                std::stringstream str(parseSubscripts(cleanScript(script))); 
     173                if (script.length() == 0 || !str.good()) return OK; 
     174 
     175                //printf("%s: \n%s\n---\n\n", getResName().c_str(),str.str().c_str()); 
     176                // get linewise 
     177                char buf[1024]; 
     178                std::string::size_type pos; 
     179                std::string line; 
     180 
     181                while (!str.eof()) 
     182                { 
     183                        // get line 
     184                        str.getline(buf, 1024); 
     185                        line = std::string(buf); 
     186 
    84187                        // check for script parameters 
    85188                        pos = line.find('^'); 
    86                         if (pos != std::string::npos){ 
    87                                 std::string param = trim(line.substr(pos+1)); 
     189                        if (pos != std::string::npos) 
     190                        { 
     191                                std::string param = boost::algorithm::trim(line.substr(pos+1)); 
    88192                                if (!setParameter(param)){ 
    89                                         NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script: Unknown local parameter %s in line %d", param.c_str(), l); 
     193                                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script: Unknown local parameter %s in line \"%s\"", param.c_str(), line.c_str()); 
    90194                                        return SCRIPT_PARSE_ERROR; 
    91195                                } 
     
    93197                        } 
    94198 
    95                         // check if we do have any command in the line  
    96                         pos = line.find_first_not_of(' ', 0); 
    97                         if (pos == std::string::npos) 
    98                                 continue; 
    99                          
    100                          
    101199                        // check for the timestamp 
    102200                        pos = line.find('|'); 
     
    106204 
    107205                        // timestamp found, so do extra stuff with this kind of commands 
    108                         if(pos != std::string::npos ){ 
    109  
     206                        if(pos != std::string::npos ) 
     207                        { 
    110208                                // retrieve the timestamp and the command and store it into the command buffer 
    111                                 std::string time = trim(line.substr(0,pos)); 
     209                                std::string time = boost::algorithm::trim(line.substr(0,pos)); 
    112210                                std::string command = line.substr(pos+1); 
    113                                  
     211 
    114212                                // try to convert the time and add the command to the list 
    115213                                try{ 
     
    125223                                        } 
    126224                                }catch(...){ 
    127                                         NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script: Unknown syntax in %d\n", l); 
     225                                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script: Unknown syntax in \"%s\"\n", line.c_str()); 
    128226                                        return SCRIPT_PARSE_ERROR; 
    129227                                } 
     
    141239                resetCommandFifo(); 
    142240                resetTimedCommandFifo(); 
    143                  
     241 
    144242                // if we got any command so we are valid 
    145243                return OK; 
     
    149247        void Script::tokenize(const std::string& str, std::string& cmd, std::vector<std::string>& tokens) 
    150248        { 
    151                 // do not tokenize if we do not get any token  
     249                // do not tokenize if we do not get any token 
    152250                if (str.length() == 0) return; 
    153                  
     251 
    154252                using namespace std; 
    155                  
     253 
    156254                // tokenize on space characters 
    157255                const string delimiters = " "; 
    158                  
     256 
    159257                // Skip delimiters at beginning. 
    160258                string::size_type lastPos = str.find_first_not_of(delimiters, 0); 
    161                  
     259 
    162260                // Find first "non-delimiter". 
    163261                string::size_type pos     = str.find_first_of(delimiters, lastPos); 
    164          
     262 
    165263                while (pos != string::npos || lastPos != string::npos) 
    166264                { 
    167265                        // Found a token, add it to the vector. 
    168                         if (pos  - lastPos > 0)  
     266                        if (pos  - lastPos > 0) 
    169267                                tokens.push_back(str.substr(lastPos, pos - lastPos)); 
    170268 
     
    230328                if (mStopTime == 0 && mRunningTimeLength > 0) 
    231329                        mStopTime = mTime + mRunningTimeLength; 
    232                          
     330 
    233331                // ----- timed commands (quasi parallel execution) ----- 
    234332                // scan through the command fifo 
     
    240338 
    241339                        //printf("%s: %f %f\n", mTimedCommand[id].cmd.c_str(), mTimedCommand[id].estimatedStart, mTimedCommand[id].time); 
    242                          
     340 
    243341                        // if the estimated start time is reeached, so start the command and remove it from the queue 
    244342                        if (mTimedCommand[id].estimatedStart < mTimedCommand[id].time) 
     
    252350                                it ++; 
    253351                } 
    254                  
     352 
    255353                // ----- sequentiall commands ----- 
    256354                if (mCommandFifo.size()) 
     
    291389                if (mCommandFifo.size() == 0 && mTimedCommandFifo.size() == 0 && !(mLoop & LOOP_COMMAND) && !(mLoop & LOOP_TIMED_COMMAND)) 
    292390                        return false; 
    293                  
     391 
    294392                return true; 
    295393        } 
    296          
     394 
    297395        //---------------------------------------------------------------------------------- 
    298396        Result Script::run() 
     
    301399                if (bRunStepwise) return step(); 
    302400 
     401                // make full run of the script 
    303402                return fullRun(); 
    304403        } 
    305404 
    306          
     405 
    307406        //---------------------------------------------------------------------------------- 
    308407        Result Script::fullRun() 
     
    329428                                Engine::sScriptEngine()->call(mCommand[id].cmd, mCommand[id].args); 
    330429                        } 
    331          
     430 
    332431                        // reset the list and check if the task is removed from the kernel 
    333432                        reset(); 
    334433                        bLoop = hasCommands(); 
    335                          
     434 
    336435                } while(bLoop && (mLoop & LOOP_COMMAND)); 
    337                          
     436 
    338437                return OK; 
    339438        } 
     
    342441        void Script::onStartScript() 
    343442        { 
    344                 // reset the script, so it can run  
     443                // do run all subscripts specified in this script 
     444                for (unsigned int i = 0; i < mSubscripts.size(); i++) 
     445                        mSubscripts[i]->execute(); 
     446 
     447                // reset the script, so it can run 
    345448                resetCommandFifo(); 
    346449                resetTimedCommandFifo(); 
     
    357460                return true; 
    358461        } 
    359          
     462 
    360463}; 
    361464 
  • nrEngine/src/ScriptLoader.cpp

    r23 r27  
    3636 
    3737        //---------------------------------------------------------------------------------- 
    38         Result ScriptLoader::initializeResourceLoader(){ 
     38        Result ScriptLoader::initializeResourceLoader() 
     39        { 
    3940                // fill out supported resource types; 
    4041                declareSupportedResourceType("Script"); 
    4142                declareSupportedResourceType("Config"); 
    4243                declareSupportedResourceType("nrScript"); 
    43                  
     44 
    4445                // we do only support dll files in windows version of our engine 
     46                declareSupportedFileType("script"); 
    4547                declareSupportedFileType("nrscript"); 
    4648                declareSupportedFileType("cfg"); 
    47                 declareSupportedFileType("script"); 
    4849 
    4950                // now delcare mapping of the types 
     
    5152                declareTypeMap("script", "nrScript"); 
    5253                declareTypeMap("cfg", "Config"); 
    53                  
     54 
    5455                return OK; 
    5556        } 
     
    6869                        // cast the resource to the iscript interface 
    6970                        IScript* scr = dynamic_cast<IScript*>(res); 
    70                          
     71 
    7172                        // load the script from a string 
    7273                        ret = scr->loadFromString(str); 
     
    7475                } 
    7576                delete fStream; 
    76                  
     77 
    7778                // return the last error 
    7879                return ret; 
     
    100101        { 
    101102                // create an instance of empty plugin 
    102                 return new EmptyScript(); 
     103                return new EmptyScript(resourceType); 
    103104        } 
    104105 
Note: See TracChangeset for help on using the changeset viewer.