Public API Reference

tools/questmanager.h

/*
    Crystal Space Entity Layer
    Copyright (C) 2004-2006 by Jorrit Tyberghein
  
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
  
    This library 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
    Library General Public License for more details.
  
    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

#ifndef __CEL_MGR_QUEST__
#define __CEL_MGR_QUEST__

#include "cstypes.h"
#include "csutil/scf.h"
#include "csutil/weakref.h"
#include "csutil/hash.h"
#include "csgeom/vector3.h"

struct iDocumentNode;
struct iChangePropertyQuestRewardFactory;
struct iCelDataBuffer;
struct iQuest;

/*
<quest name="test">
    <state name="notstarted">
    </state>

    <state name="start">
        <trigger type="ininventory">
            <fireon entity="$actor_entity" new_entity="computer_part" />
            <reward type="newstate" state="state2" />
            <reward type="increasestats" statname="HP" value="3" />
        </trigger>
        <trigger type="objectdestroyed">
            <fireon entity="barrel" />
            <reward type="newstate" state="finalstate" />
            <reward type="increasestats" statname="HP" value="10" />
        </trigger>
    </state>

    <state name="state2">
        <trigger type="clickonentity">
            <fireon entity="" />
        </trigger>
        <trigger type="cel.questtrigger.entersector">
            <fireon entity="player" sector="room" />
        </trigger>
    </state>

    <sequence name="seqTest">
        <op type="movemesh" duration="2000" entity="door"
                x="0" y="4" z="0" />
        <op type="lightcolor" duration="2000" entity="lightbulb"
                red="1" green="1" blue="1" />
        <delay time="2000" />
    </sequence>

    <start>notstarted</start>
</quest>
*/

typedef csHash<csStringBase,csStringBase> celQuestParams;

//-------------------------------------------------------------------------
// Triggers
//-------------------------------------------------------------------------

struct iQuestTrigger;

struct iQuestTriggerCallback : public virtual iBase
{
  SCF_INTERFACE (iQuestTriggerCallback, 0, 0, 1);

  virtual void TriggerFired (iQuestTrigger* trigger) = 0;
};

struct iQuestTrigger : public virtual iBase
{
  SCF_INTERFACE (iQuestTrigger, 0, 0, 1);

  virtual void RegisterCallback (iQuestTriggerCallback* callback) = 0;

  virtual void ClearCallback () = 0;

  virtual void ActivateTrigger () = 0;

  virtual void DeactivateTrigger () = 0;

  virtual bool Check () = 0;

  virtual bool LoadAndActivateTrigger (iCelDataBuffer* databuf) = 0;

  virtual void SaveTriggerState (iCelDataBuffer* databuf) = 0;
};

struct iQuestTriggerFactory : public virtual iBase
{
  SCF_INTERFACE (iQuestTriggerFactory, 0, 0, 1);

  virtual csPtr<iQuestTrigger> CreateTrigger (iQuest* quest,
        const celQuestParams& params) = 0;

  virtual bool Load (iDocumentNode* node) = 0;
};

struct iQuestTriggerType : public virtual iBase
{
  SCF_INTERFACE (iQuestTriggerType, 0, 0, 1);

  virtual const char* GetName () const = 0;
  
  virtual csPtr<iQuestTriggerFactory> CreateTriggerFactory () = 0;
};

//-------------------------------------------------------------------------
// Rewards
//-------------------------------------------------------------------------

struct iQuestReward : public virtual iBase
{
  SCF_INTERFACE (iQuestReward, 0, 0, 1);
  virtual void Reward () = 0;
};

struct iQuestRewardFactory : public virtual iBase
{
  SCF_INTERFACE (iQuestRewardFactory, 0, 0, 1);

  virtual csPtr<iQuestReward> CreateReward (iQuest* quest,
        const celQuestParams& params) = 0;

  virtual bool Load (iDocumentNode* node) = 0;
};

struct iQuestRewardType : public virtual iBase
{
  SCF_INTERFACE (iQuestRewardType, 0, 0, 1);

  virtual const char* GetName () const = 0;
  
  virtual csPtr<iQuestRewardFactory> CreateRewardFactory () = 0;
};

//-------------------------------------------------------------------------
// Sequence operations
//-------------------------------------------------------------------------

struct iQuestSeqOp : public virtual iBase
{
  SCF_INTERFACE (iQuestSeqOp, 0, 0, 1);
  
  virtual void Init () = 0;

  virtual bool Load (iCelDataBuffer* databuf) = 0;

  virtual void Save (iCelDataBuffer* databuf) = 0;

  virtual void Do (float time) = 0;
};

struct iQuestSeqOpFactory : public virtual iBase
{
  SCF_INTERFACE (iQuestSeqOpFactory, 0, 0, 1);

  virtual csPtr<iQuestSeqOp> CreateSeqOp (const celQuestParams& params) = 0;

  virtual bool Load (iDocumentNode* node) = 0;
};

struct iQuestSeqOpType : public virtual iBase
{
  SCF_INTERFACE (iQuestSeqOpType, 0, 0, 1);

  virtual const char* GetName () const = 0;
  
  virtual csPtr<iQuestSeqOpFactory> CreateSeqOpFactory () = 0;
};

struct iQuestSequence;

struct iQuestSequenceCallback : public virtual iBase
{
  SCF_INTERFACE (iQuestSequenceCallback, 0, 0, 1);

  virtual void SequenceFinished (iQuestSequence* sequence) = 0;
};

struct iQuestSequence : public virtual iBase
{
  SCF_INTERFACE (iQuestSequence, 0, 0, 1);

  virtual const char* GetName () const = 0;

  virtual bool Start (csTicks delay) = 0;

  virtual void Finish () = 0;

  virtual void Abort () = 0;

  virtual bool IsRunning () = 0;

  virtual void AddSequenceCallback (iQuestSequenceCallback* cb) = 0;
  virtual void RemoveSequenceCallback (iQuestSequenceCallback* cb) = 0;
};

//-------------------------------------------------------------------------
// The Quest
//-------------------------------------------------------------------------

struct iQuest : public virtual iBase
{
  SCF_INTERFACE (iQuest, 0, 0, 1);

  virtual bool SwitchState (const char* state) = 0;

  virtual const char* GetCurrentState () const = 0;

  virtual bool LoadState (const char* state, iCelDataBuffer* databuf) = 0;

  virtual void SaveState (iCelDataBuffer* databuf) = 0;

  virtual iQuestSequence* FindSequence (const char* name) = 0;
};

struct iQuestTriggerResponseFactory : public virtual iBase
{
  SCF_INTERFACE (iQuestTriggerResponseFactory, 0, 0, 1);

  virtual void SetTriggerFactory (iQuestTriggerFactory* trigger_fact) = 0;

  virtual void AddRewardFactory (iQuestRewardFactory* reward_fact) = 0;
};

struct iQuestStateFactory : public virtual iBase
{
  SCF_INTERFACE (iQuestStateFactory, 0, 0, 1);

  virtual const char* GetName () const = 0;

  virtual iQuestTriggerResponseFactory* CreateTriggerResponseFactory () = 0;
};

struct iQuestSequenceFactory : public virtual iBase
{
  SCF_INTERFACE (iQuestSequenceFactory, 0, 0, 1);

  virtual const char* GetName () const = 0;

  virtual bool Load (iDocumentNode* node) = 0;

  virtual void AddSeqOpFactory (iQuestSeqOpFactory* seqopfact,
        const char* duration) = 0;

  virtual void AddDelay (const char* delay) = 0;
};

struct iQuestFactory : public virtual iBase
{
  SCF_INTERFACE (iQuestFactory, 0, 0, 1);

  virtual const char* GetName () const = 0;
  
  virtual csPtr<iQuest> CreateQuest (const celQuestParams& params) = 0;

  virtual bool Load (iDocumentNode* node) = 0;

  virtual iQuestStateFactory* GetState (const char* name) = 0;

  virtual iQuestStateFactory* CreateState (const char* name) = 0;

  virtual iQuestSequenceFactory* GetSequence (const char* name) = 0;

  virtual iQuestSequenceFactory* CreateSequence (const char* name) = 0;

  virtual const char* GetDefaultParameter (const char* name) const = 0;

  virtual void SetDefaultParameter (const char* name,const char* value) = 0;
  
  virtual void ClearDefaultParameters () = 0;

};

//-------------------------------------------------------------------------
// The Quest Manager
//-------------------------------------------------------------------------

struct iQuestManager : public virtual iBase
{
  SCF_INTERFACE (iQuestManager, 0, 0, 1);

  virtual bool RegisterTriggerType (iQuestTriggerType* trigger) = 0;

  virtual iQuestTriggerType* GetTriggerType (const char* name) = 0;

  virtual bool RegisterRewardType (iQuestRewardType* trigger) = 0;

  virtual iQuestRewardType* GetRewardType (const char* name) = 0;

  virtual bool RegisterSeqOpType (iQuestSeqOpType* seqop) = 0;

  virtual iQuestSeqOpType* GetSeqOpType (const char* name) = 0;

  virtual iQuestFactory* GetQuestFactory (const char* name) = 0;

  virtual iQuestFactory* CreateQuestFactory (const char* name) = 0;

  virtual const char* ResolveParameter (
        const celQuestParams& params,
        const char* param) = 0;

  virtual bool Load (iDocumentNode* node) = 0;

  virtual iQuestRewardFactory* AddNewStateReward (
        iQuestTriggerResponseFactory* response,
        const char* entity_par, const char* state_par) = 0;

  virtual iQuestRewardFactory* AddDebugPrintReward (
        iQuestTriggerResponseFactory* response,
        const char* msg_par) = 0;

  virtual iQuestRewardFactory* AddInventoryReward (
        iQuestTriggerResponseFactory* response,
        const char* entity_par, const char* child_entity_par) = 0;

  virtual iQuestRewardFactory* AddSequenceReward (
        iQuestTriggerResponseFactory* response,
        const char* entity_par, const char* sequence_par,
        const char* delay_par) = 0;

  virtual iQuestRewardFactory* AddCsSequenceReward (
        iQuestTriggerResponseFactory* response,
        const char* sequence_par, const char* delay_par) = 0;

  virtual iQuestRewardFactory* AddSequenceFinishReward (
        iQuestTriggerResponseFactory* response,
        const char* entity_par, const char* sequence_par) = 0;

  virtual iChangePropertyQuestRewardFactory* AddChangePropertyReward (
        iQuestTriggerResponseFactory* response,
        const char* entity_par, const char* prop_par) = 0;

  virtual iQuestTriggerFactory* SetTimeoutTrigger (
        iQuestTriggerResponseFactory* response,
        const char* timeout_par) = 0;

  virtual iQuestTriggerFactory* SetEnterSectorTrigger (
        iQuestTriggerResponseFactory* response,
        const char* entity_par, const char* sector_par) = 0;

  virtual iQuestTriggerFactory* SetMeshEnterSectorTrigger (
        iQuestTriggerResponseFactory* response,
        const char* entity_par, const char* sector_par) = 0;

  virtual iQuestTriggerFactory* SetSequenceFinishTrigger (
        iQuestTriggerResponseFactory* response,
        const char* entity_par, const char* sequence_par) = 0;

  virtual iQuestTriggerFactory* SetPropertyChangeTrigger (
        iQuestTriggerResponseFactory* response,
        const char* entity_par, const char* prop_par,
        const char* value_par) = 0;

  virtual iQuestTriggerFactory* SetTriggerTrigger (
        iQuestTriggerResponseFactory* response,
        const char* entity_par, bool do_leave = false) = 0;

  virtual iQuestTriggerFactory* SetWatchTrigger (
        iQuestTriggerResponseFactory* response,
        const char* entity_par, const char* target_entity_par,
        const char* checktime_par,
        const char* radius_par) = 0;
};

//-------------------------------------------------------------------------
// Specific trigger implementations.
//-------------------------------------------------------------------------

struct iTimeoutQuestTriggerFactory : public virtual iBase
{
  SCF_INTERFACE (iTimeoutQuestTriggerFactory, 0, 0, 1);

  virtual void SetTimeoutParameter (const char* timeout_par) = 0;
};

struct iPropertyChangeQuestTriggerFactory : public virtual iBase
{
  SCF_INTERFACE (iPropertyChangeQuestTriggerFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetPropertyParameter (const char* prop) = 0;

  virtual void SetValueParameter (const char* value) = 0;
};

struct iMeshSelectQuestTriggerFactory : public virtual iBase
{
  SCF_INTERFACE (iMeshSelectQuestTriggerFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;
};

struct iInventoryQuestTriggerFactory : public virtual iBase
{
  SCF_INTERFACE (iInventoryQuestTriggerFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetChildEntityParameter (const char* child_entity) = 0;
};

struct iEnterSectorQuestTriggerFactory : public virtual iBase
{
  SCF_INTERFACE (iEnterSectorQuestTriggerFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetSectorParameter (const char* sector) = 0;
};

struct iSequenceFinishQuestTriggerFactory : public virtual iBase
{
  SCF_INTERFACE (iSequenceFinishQuestTriggerFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetSequenceParameter (const char* sequence) = 0;
};

struct iTriggerQuestTriggerFactory : public virtual iBase
{
  SCF_INTERFACE (iTriggerQuestTriggerFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void EnableLeave () = 0;
};

struct iWatchQuestTriggerFactory : public virtual iBase
{
  SCF_INTERFACE (iWatchQuestTriggerFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetTargetEntityParameter (const char* entity,
      const char* tag = 0) = 0;

  virtual void SetChecktimeParameter (const char* time) = 0;

  virtual void SetRadiusParameter (const char* radius) = 0;

  virtual void SetOffsetParameter (const char* offsetx,
      const char* offsety, const char* offsetz) = 0;
};

//-------------------------------------------------------------------------
// Specific reward implementations.
//-------------------------------------------------------------------------

struct iDebugPrintQuestRewardFactory : public virtual iBase
{
  SCF_INTERFACE (iDebugPrintQuestRewardFactory, 0, 0, 1);

  virtual void SetMessageParameter (const char* msg) = 0;
};

struct iNewStateQuestRewardFactory : public virtual iBase
{
  SCF_INTERFACE (iNewStateQuestRewardFactory, 0, 0, 1);

  virtual void SetStateParameter (const char* state) = 0;

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;
};

struct iChangePropertyQuestRewardFactory : public virtual iBase
{
  SCF_INTERFACE (iChangePropertyQuestRewardFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity) = 0;

  virtual void SetPCParameter (const char* pc, const char* tag) = 0;

  virtual void SetPropertyParameter (const char* prop) = 0;

  virtual void SetStringParameter (const char* pstring) = 0;

  virtual void SetLongParameter (const char* plong) = 0;

  virtual void SetFloatParameter (const char* pfloat) = 0;

  virtual void SetBoolParameter (const char* pbool) = 0;

  virtual void SetDiffParameter (const char* pdiff) = 0;

  virtual void SetToggle () = 0;
};

struct iInventoryQuestRewardFactory : public virtual iBase
{
  SCF_INTERFACE (iInventoryQuestRewardFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetChildEntityParameter (const char* entity,
        const char* tag = 0) = 0;
};

struct iCsSequenceQuestRewardFactory : public virtual iBase
{
  SCF_INTERFACE (iCsSequenceQuestRewardFactory, 0, 0, 1);

  virtual void SetSequenceParameter (const char* sequence) = 0;

  virtual void SetDelayParameter (const char* delay) = 0;
};

struct iSequenceQuestRewardFactory : public virtual iBase
{
  SCF_INTERFACE (iSequenceQuestRewardFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetSequenceParameter (const char* sequence) = 0;

  virtual void SetDelayParameter (const char* delay) = 0;
};

struct iSequenceFinishQuestRewardFactory : public virtual iBase
{
  SCF_INTERFACE (iSequenceFinishQuestRewardFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetSequenceParameter (const char* sequence) = 0;
};

struct iMessageQuestRewardFactory : public virtual iBase
{
  SCF_INTERFACE (iMessageQuestRewardFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity) = 0;

  virtual void SetIDParameter (const char* id) = 0;

  virtual void AddParameter (celDataType type, csStringID id,
      const char* name, const char* value) = 0;
};

struct iActionQuestRewardFactory : public virtual iBase
{
  SCF_INTERFACE (iActionQuestRewardFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity) = 0;

  virtual void SetIDParameter (const char* id) = 0;

  virtual void SetPropertyClassParameter (const char* propertyclass) = 0;

  virtual void SetTagParameter (const char* tag) = 0;

  virtual void AddParameter (celDataType type, csStringID id,
      const char* name, const char* value) = 0;
};

struct iDestroyEntityQuestRewardFactory : public virtual iBase
{
  SCF_INTERFACE (iDestroyEntityQuestRewardFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity) = 0;
};


//-------------------------------------------------------------------------
// Specific sequence operation implementations.
//-------------------------------------------------------------------------

struct iDebugPrintQuestSeqOpFactory : public virtual iBase
{
  SCF_INTERFACE (iDebugPrintQuestSeqOpFactory, 0, 0, 1);

  virtual void SetMessageParameter (const char* msg) = 0;
};

struct iTransformQuestSeqOpFactory : public virtual iBase
{
  SCF_INTERFACE (iTransformQuestSeqOpFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetVectorParameter (const char* vectorx, const char* vectory,
        const char* vectorz) = 0;

  virtual void SetRotationParameter (int rot_axis, const char* rot_angle) = 0;
};

struct iMovePathQuestSeqOpFactory : public virtual iBase
{
  SCF_INTERFACE (iMovePathQuestSeqOpFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void AddPathNode (const char* sectorname, const char* node,
        const char* time) = 0;
};

struct iLightQuestSeqOpFactory : public virtual iBase
{
  SCF_INTERFACE (iLightQuestSeqOpFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetRelColorParameter (const char* red, const char* green,
        const char* blue) = 0;

  virtual void SetAbsColorParameter (const char* red, const char* green,
        const char* blue) = 0;
};

//-------------------------------------------------------------------------

#define CEL_DECLARE_REWARDTYPE(name,id)                                 \
class cel##name##RewardType : public scfImplementation1<                \
                cel##name##RewardType,iQuestRewardType>                 \
{                                                                       \
public:                                                                 \
  iObjectRegistry* object_reg;                                          \
  csWeakRef<iCelPlLayer> pl;                                            \
  cel##name##RewardType (iObjectRegistry* object_reg);                  \
  virtual ~cel##name##RewardType () { }                                 \
  virtual const char* GetName () const { return id; }                   \
  virtual csPtr<iQuestRewardFactory> CreateRewardFactory ();            \
};

#define CEL_IMPLEMENT_REWARDTYPE(name)                                  \
cel##name##RewardType::cel##name##RewardType (                          \
        iObjectRegistry* object_reg) : scfImplementationType (this)     \
{                                                                       \
  cel##name##RewardType::object_reg = object_reg;                       \
  pl = csQueryRegistry<iCelPlLayer> (object_reg);                       \
}                                                                       \
csPtr<iQuestRewardFactory> cel##name##RewardType::CreateRewardFactory ()\
{                                                                       \
  cel##name##RewardFactory* fact = new                                  \
        cel##name##RewardFactory (this);                                \
  return fact;                                                          \
}

#define CEL_DECLARE_TRIGGERTYPE(name,id)                                \
class cel##name##TriggerType : public scfImplementation1<               \
                cel##name##TriggerType,iQuestTriggerType>               \
{                                                                       \
public:                                                                 \
  iObjectRegistry* object_reg;                                          \
  csWeakRef<iCelPlLayer> pl;                                            \
  cel##name##TriggerType (iObjectRegistry* object_reg);                 \
  virtual ~cel##name##TriggerType () { }                                \
  virtual const char* GetName () const { return id; }                   \
  virtual csPtr<iQuestTriggerFactory> CreateTriggerFactory ();          \
};

#define CEL_IMPLEMENT_TRIGGERTYPE(name)                                 \
cel##name##TriggerType::cel##name##TriggerType (                        \
        iObjectRegistry* object_reg) : scfImplementationType (this)     \
{                                                                       \
  cel##name##TriggerType::object_reg = object_reg;                      \
  pl = csQueryRegistry<iCelPlLayer> (object_reg);                       \
}                                                                       \
csPtr<iQuestTriggerFactory> cel##name##TriggerType::CreateTriggerFactory () \
{                                                                       \
  cel##name##TriggerFactory* fact = new cel##name##TriggerFactory (this); \
  return fact;                                                          \
}

#define CEL_DECLARE_SEQOPTYPE(name,id)                                  \
class cel##name##SeqOpType : public scfImplementation1<                 \
        cel##name##SeqOpType,iQuestSeqOpType>                           \
{                                                                       \
public:                                                                 \
  iObjectRegistry* object_reg;                                          \
  csWeakRef<iCelPlLayer> pl;                                            \
  cel##name##SeqOpType (iObjectRegistry* object_reg);                   \
  virtual ~cel##name##SeqOpType () { }                                  \
  virtual const char* GetName () const { return id; }                   \
  virtual csPtr<iQuestSeqOpFactory> CreateSeqOpFactory ();              \
};

#define CEL_IMPLEMENT_SEQOPTYPE(name)                                   \
cel##name##SeqOpType::cel##name##SeqOpType (                            \
        iObjectRegistry* object_reg) : scfImplementationType (this)     \
{                                                                       \
  cel##name##SeqOpType::object_reg = object_reg;                        \
  pl = csQueryRegistry<iCelPlLayer> (object_reg);                       \
}                                                                       \
csPtr<iQuestSeqOpFactory> cel##name##SeqOpType::CreateSeqOpFactory ()   \
{                                                                       \
  cel##name##SeqOpFactory* fact = new cel##name##SeqOpFactory (this);   \
  return fact;                                                          \
}

#endif // __CEL_MGR_QUEST__

---