spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

PreparedAction::PreparedAction(Character& theCharacter, Action* PrepareAction, Action* MainAction):
Action(theCharacter),
m_PrepareAction(PrepareAction),
m_MainAction(MainAction),
m_Prepared(false)
{
}

PreparedAction::~PreparedAction()
{
    delete m_PrepareAction;
    delete m_MainAction;
}

bool PreparedAction::InhMove(float Time)
{
    if(m_Prepared)
    {
        return m_MainAction->Move(Time);
    }
    else //die action muss noch vorbereitet werden

    {
        if(m_MainAction->Startable())
        {
            m_PrepareAction->Stop();
            m_Prepared=true;
            m_MainAction->Start();
            return m_MainAction->Move(Time);
        }
        else
        {
            return m_PrepareAction->Move(Time);
        }
    }
}

void PreparedAction::InhStart()
{
    if(m_Prepared)
        m_MainAction->Start();
    else
        m_PrepareAction->Start();
}

void PreparedAction::InhStop()
{
    if(m_Prepared)
        m_MainAction->Stop();
    else
        m_PrepareAction->Stop();
}

bool PreparedAction::Breakable()
{
    if(m_Prepared)
        return m_MainAction->Breakable();
    else
        return m_PrepareAction->Breakable();
}

C-/C++-Quelltext

StartAction(new Action::PreparedAction(*this, new Action::Walk(*this, TheTarget),
    new Action::AttackMelee(*this, TheTarget)));

C-/C++-Quelltext

class Action
{
public:
    Action(Character &theCharacter, bool Breakable=true);//Der Charakter, der die Aktion ausführt

    virtual ~Action();
    bool Move(float Time); //gibt zurück, ob die Action fertig ist


    virtual bool Startable();//ob die Aktion gestartet werden kann

    virtual bool Breakable();//gibt an, ob eine Aktion unterbrochen werden kann

                        //(laufen kann man unterbrechen, wenn man sich nach einem schlag aushohlen muss, kann man das nicht unterbrechen)

    void Start();
    void Stop();
    bool IsStarted();
protected:
    float GetActionParam(string Action, string Key);

    Character& m_Character;
    CharacterValues &m_CharacterValues;
private:
    virtual bool InhMove(float Time) = 0;
    virtual void InhStart()=0;
    virtual void InhStop()=0;

    bool m_Breakable;
    bool m_Started;
};




//eine Aktion, die erste eine ander ausführt um sie vorzubereiten

class PreparedAction: public Action
{
public:
    PreparedAction(Character& theCharacter, Action* PrepareAction, Action* MainAction);
    ~PreparedAction();

    bool InhMove(float Time);
    void InhStart();
    void InhStop();

    bool Breakable();
private:
    Action* m_PrepareAction;
    Action* m_MainAction;

    bool m_Prepared;    //Ob die prepareaction schon fertig ist

};