ActionComponent.hpp

Go to the documentation of this file.

/*
SagaEngine library
Copyright (c) 2002-2006 Skalden Studio AS

This software is provided 'as-is', without any express or implied 
warranty. In no event will the authors be held liable for any 
damages arising from the use of this software.

Permission is granted to distribute the library under the terms of the 
Q Public License version 1.0. Be sure to read and understand the license
before using the library. It should be included here, or you may read it
at http://www.trolltech.com/products/qt/licenses/licensing/qpl

The original version of this library can be located at:
http://www.sagaengine.com/

Rune Myrland
rune@skalden.com
*/


#ifndef ActionComponent_hpp
#define ActionComponent_hpp

#include "sim_action.hpp"
#include "comp/Component.hpp"
#include "comp/Composite.hpp"
#include "../sim.hpp"
#include "Action.hpp"
#include "ActionQueue.hpp"
#include "ActionAndParameter.hpp"
#include "ActionFeed.hpp"

namespace se_core {

    class _SeCoreExport ActionComponent : public Component {
    public:
        typedef ComponentPtr<ActionComponent, sct_ACTION> Ptr;

        ActionComponent(Composite* owner);

        ~ActionComponent();

        void planAction(short channel, const Action& action, const Parameter* parameter = 0) const;
        void planAction(short channel, const ActionAndParameter& action) const;
        void planActionIfNone(short channel, const ActionAndParameter& action) const;

        void clearPlannedAction(short channel) const;

        void disrupt();

        void resume();

        bool disrupt(short channel);

        void unpause(short channel);

        void scheduleForDestruction();

        void resetActionFeed() {
            feed_ = 0;
        }

        enum { fb_UNDEFINED, fb_SPEECH_FINISHED, fb_USER_DEFINED };
        void castFeedbackEvent(int type);
        void setActionFeed(ActionFeed* feed);

        void setActive(bool state);
        void setScriptActive(bool state);

    protected:
        friend class ActionQueue;

        void cleanup();

        inline void perform(long when, short channel);

        inline void scheduleNextAction(long when, short channel);

        unsigned short actionSchedule(short channel) { return presentActionScheduledComplete_[channel]; }

        // Helper function for planAction and scheduleNextAction(long when, short channel);
        void continueAction(long when, short channel);
        void scheduleNextAction(short channel);

        void nextScriptAction(short channel);

    protected:
        mutable ActionAndParameter presentAction_[CHANNEL_COUNT];
        mutable ActionAndParameter plannedAction_[CHANNEL_COUNT];

        mutable unsigned short presentActionScheduledComplete_[CHANNEL_COUNT];


        ActionFeed* feed_;

    protected:
    };


    inline void ActionComponent
    ::perform(long when, short channel) {
        const Action* a = presentAction_[channel].action();
        Parameter& p = presentAction_[channel].parameter();
        a->perform(when, *this, p);
    }


    inline void ActionComponent
    ::scheduleNextAction(long when, short channel) {
        if(!isActive() || isDead()) {
            presentAction_[ channel ].resetAction();
            return;
        }
        
        ActionAndParameter& aap = presentAction_[channel];
        if(aap.isDisrupted()) {
            aap.resetAction();
            aap.setDisrupted(false);
            return;
        }

        if(aap.hasAction() && aap.action()->isContinuing(*this, aap.parameter())) {
            continueAction(when, channel);
            return;
        }

        if(!plannedAction_[channel].hasAction()) {
            nextScriptAction(channel);
        }

        // No action planned?
        if(aap.hasAction() && !plannedAction_[channel].hasAction()) {
            // Is present action repeating (until another is planned)?
            //ActionAndParameter& aap = presentAction_[channel];
            if(aap.action()->isRepeating(when, *this, aap.parameter())) {
                // If, yeah - plan to do present action again
                plannedAction_[channel] = presentAction_[channel];
            }
            else {
                // Or not, present action is complete
                presentAction_[channel].resetAction();
            }
        }

        // Still no action planned? Then we are finished
        if(!plannedAction_[channel].hasAction()) {
            return;
        }

        // Put planned action into action queue
        scheduleNextAction(channel);
    }

}

#endif

---

Home Page | SagaEngine trunk (updated nightly) reference generated Sun Dec 2 20:06:11 2007 by Doxygen version 1.3.9.1.