---

action.h

// $Id: action_8h-source.html,v 1.2 2002/06/20 17:09:53 mkrohn5 Exp $

// Action Header File
// Written by: Alberto Barsella

// Copyright (C) 1999-2001, Alberto Barsella <Alberto.Barsella@univ-lille1.fr>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 1, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

#ifndef __TACTION_INCLUDED
#define __TACTION_INCLUDED

#include "common/global.h"
#include "common/plist.h"
#include "gamelogic/property.h"
#include "common/datapackage.h"

#include <string>
#include <vector>
using namespace std;

class TActionObject;
class TAction;
class TActionSequencer;
class TDataPackageList;




//----------------------------------------  Some evil defines  ----------------------------------------
// this makes writing actions a lot easier

#define ActionClass(a)         TAction_##a
#define ACString(a)            "TAction_"#a
#define ActionType(a)          ACTION_##a
#define ActionProto(a)         Action##a##Proto

#define DefineNewAction(a, b)  ActionClass(a) ActionProto(a)(b, &ActionType(a)); \
                               TActionType ActionType(a); \
                               ActionClass(a)::ActionClass(a)(const string& name, TActionType* type) : TAction(name, type) \
                               { initialize(); }

#define DeclareNewAction(a) extern TActionType ActionType(a); \
                            class ActionClass(a) : public TAction { \
                              public: \
                                ActionClass(a)(const string& name, TActionType* type); \
                                ~ActionClass(a)() { uninitialize(); } \
                                bool execute(); \
                                bool loadAttributes(TDataPackageList* in); \
                                bool saveAttributes(TDataPackageList* out) const; \
                              private: \
                                ActionClass(a)(const TActionType type, const string* tn) : TAction(type, tn) { initialize(); } \
                                void initialize(); \
                                void uninitialize(); \
                                TAction* _new() const { return new ActionClass(a)(Type, TypeName); }

#define EndDeclareAction    }

#define Unsupported(type)   Fatal( #type, "unsupported method", "an unsupported method was called for action "#type, -1)

#define Member(a)  ActionClass(a)

typedef int2 TActionType;





class TAction : public TLinkable {
  public:
    // this is only used at prototype creation
    // all creation of actions should pass through Create
    TAction(const string& name, TActionType* type);

    // destructor
    virtual ~TAction();

    virtual bool load(TDataPackageList* in);
    virtual bool loadAttributes(TDataPackageList* in);
    virtual bool save(TDataPackageList* out) const;
    virtual bool saveAttributes( TDataPackageList* out) const;

    void markAsExecuted();
    void objectValidationIsNeeded();
    virtual bool validateObjects();
    virtual bool checkActionConflicts();
    virtual bool resolveActionConflicts();

    virtual bool canUndo() const;

    virtual bool execute() = 0;
    void setActor( TActionObject* actor );
    void setCreator( TRace* creator );

    // create a new action of the specified type
static TAction* create(const string& actname);

    // verify type of an action
    bool is(const TActionType type) const;
    virtual bool isPlayerAction() const;
    const TActionType getActionType() const;
    const string& getActionName() const;

    // overloading of TType methods
    int2 getType() const;
    const string& getTypeName() const;
    TRace* getCreator() const;

  protected:
    TAction(const TActionType type, const string* tn); // only invoked by _new
    virtual TAction* _new() const = 0;

    TActionType Type;
    const string* TypeName;

    TLink<TRace> fCreator;
    TLink<TActionObject> fActor;
    list<TLink<TActionObject>*> Objects;
    list<TLink<TActionObject>*> Observers;

  private:
static TAction* protoManager(TAction* act, const string& actname);

    bool Executed;
    bool ObjectsAreValid;
    bool IsPrototype;

    // global action type counter
static uint4 iNumActionTypes;
};


ostream& operator<<(ostream& os, const TAction& Act);



class TActionObject : public TProperty
{
    friend class TAction;

  public:
    TActionObject();
    virtual ~TActionObject();

    virtual bool canPerformAction(const TAction& action);
    virtual bool canBeObjectInAction(const TAction& action);
    virtual bool canObserveAction(const TAction& action);

    virtual bool load( TDataPackageList* in );
    virtual bool save( TDataPackageList* out ) const;

    // overloading of TType methods done by derived classes

  private:
};



class TActionSequencer {
  public:
    TActionSequencer(const bool client);
    ~TActionSequencer();

    bool isInClientMode() const;
    void clear();
    bool addAction(TAction* action);
    bool runSequence();
    bool saveLists(ofstream& out) const;

  private:
    bool ClientMode;

    typedef map<TObjectID, TPList<TAction> > tActionTable;

    tActionTable ActionLists;
};


#endif        // __TACTION_INCLUDED

---