npcoperations.h

Go to the documentation of this file.

/*
* npcoperations.h
*
* Copyright (C) 2007 Atomic Blue ([email protected], http://www.atomicblue.org)
*
*
* 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 (version 2 of the License)
* 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.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*
*/
#ifndef __NPCOPERATIONS_H__
#define __NPCOPERATIONS_H__

#include <psstdint.h>

//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csgeom/vector3.h>
#include <csutil/csstring.h>

struct iDocumentNode;
struct iSector;

//=============================================================================
// Library Includes
//=============================================================================
#include "util/psconst.h"
#include "util/pspath.h"
#include "util/pspathnetwork.h"
#include <tools/celhpf.h>
#include "net/npcmessages.h"
#include "util/edge.h"
#include "util/mathscript.h"

//=============================================================================
// Project Includes
//=============================================================================
#include "npc.h"
#include "reaction.h"
#include "perceptions.h"

class NPC;
class gemNPCObject;
class gemNPCActor;
class MoveOperation;
class Waypoint;
class Behavior;

class ScriptOperation
{
public:
    enum VelSource
    {
        VEL_DEFAULT,
        VEL_USER,
        VEL_WALK,
        VEL_RUN
    };

    // Used to indicate the result of the Run and Advance operations.
    enum OperationResult
    {
        OPERATION_NOT_COMPLETED, 
        OPERATION_COMPLETED,     
        OPERATION_FAILED         
    };

    enum State
    {
        READY_TO_RUN,
        RUNNING,
        INTERRUPTED,
        COMPLETED
    };

protected:
    // Start of instance temp variables. These dosn't need to be copied.
    csString             name;

    csVector3            interrupted_position;
    iSector*             interrupted_sector;
    float                interrupted_angle;

    int                  consecCollisions; 

    Behavior*            parent;

    State                state;
    // End of instance temp variables.

    // Start of shared values between operation

    // Failure handling
    csString             failurePerception;    

    // Velocity is shared for all move operations
    VelSource            velSource;            
    float                vel;                  
    float                ang_vel;              

    // Start Check Move OK parameters
    // Configuration paramters. Set by using LoadCheckMoveOk
    csString             collision;       
    csString             outOfBounds;     
    csString             inBounds;        
    csString             falling;        
    bool                 checkTribeHome;  
    // End Check Move OK parameters


    // End of shared values between operations

    int StartMoveTo(NPC* npc, const csVector3 &dest, iSector* sector, float vel,const char* action, float &angle);

    void TurnTo(NPC* npc,const csVector3 &dest, iSector* destsect, csVector3 &forward, float &angle);

    static void StopMovement(NPC* npc);

public:

    ScriptOperation(const char* sciptName);
    ScriptOperation(const ScriptOperation* other);
    virtual ~ScriptOperation() {}

    virtual OperationResult Run(NPC* npc,bool interrupted)=0;
    virtual OperationResult Advance(float timedelta,NPC* npc);

    virtual void InterruptOperation(NPC* npc);
    virtual bool AtInterruptedPosition(const csVector3 &pos, const iSector* sector);
    virtual bool AtInterruptedAngle(const csVector3 &pos, const iSector* sector, float angle);
    virtual bool AtInterruptedPosition(NPC* npc);
    virtual bool AtInterruptedAngle(NPC* npc);

    virtual void SetState(State state)
    {
        this->state = state;
    }
    virtual State GetState() const
    {
        return state;
    }


private:
    void SendCollitionPerception(NPC* npc);

public:
    virtual bool CheckMoveOk(NPC* npc, csVector3 oldPos, iSector* oldSector,
                             const csVector3 &newPos, iSector* newSector, int resultFromExtrapolate);

    virtual bool CheckEndPointOk(NPC* npc, const csVector3 &myPos, iSector* mySector,
                                 const csVector3 &endPos, iSector* endSector);

    virtual const csString &GetCollisionPerception(NPC* npc);

    virtual const csString &GetOutOfBoundsPerception(NPC* npc);

    virtual const csString &GetInBoundsPerception(NPC* npc);

    virtual const csString &GetFallingPerception(NPC* npc);

    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy()=0;

    virtual float GetVelocity(NPC* npc);

    virtual float GetAngularVelocity(NPC* npc);
    bool LoadVelocity(iDocumentNode* node);

    bool LoadCheckMoveOk(iDocumentNode* node);

    void CopyCheckMoveOk(ScriptOperation*  source);

    void AddRandomRange(csVector3 &dest, float radius, float margin = 0.0);

    void SetAnimation(NPC* npc, const char* name);

    virtual const char* GetName() const
    {
        return name.GetDataSafe();
    };

    virtual void Failure(NPC* npc);

    void SetParent(Behavior* behavior);
};

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

class MovementOperation : public ScriptOperation
{
protected:

    // Instance variables
    csRef<iCelHPath> path;

    // Cache values for end position
    csVector3 endPos;
    iSector*  endSector;

    float currentDistance;          

    // Operation parameters
    csString         action;        

    // Constructor
    MovementOperation(const MovementOperation* other);

public:

    MovementOperation(const char*  name);

    virtual ~MovementOperation() { }

    virtual bool Load(iDocumentNode* node);

    bool EndPointChanged(const csVector3 &endPos, const iSector* endSector) const;

    virtual bool GetEndPosition(NPC* npc, const csVector3 &myPos, const iSector* mySector,
                                csVector3 &endPos, iSector* &endSector) = 0;

    virtual bool UpdateEndPosition(NPC* npc, const csVector3 &myPos, const iSector* mySector,
                                   csVector3 &endPos, iSector* &endSector) = 0;

    virtual OperationResult Run(NPC* npc,bool interrupted);

    virtual OperationResult Advance(float timedelta,NPC* npc);

    virtual void InterruptOperation(NPC* npc);

};

//---------------------------------------------------------------------------
//         Following section contain specefix NPC operations.
//         Ordered alphabeticaly, with exception for when needed
//         due to inheritance. MoveOperation is out of order compared
//         to the implementation file.
//---------------------------------------------------------------------------

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

class AssessOperation : public ScriptOperation
{
protected:
    csString physicalAssessmentPerception;
    csString magicalAssessmentPerception;
    csString overallAssessmentPerception;
public:

    AssessOperation(): ScriptOperation("Assess") {};
    virtual ~AssessOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class BuildOperation : public ScriptOperation
{
protected:
    bool pickupable;
public:

    BuildOperation(): ScriptOperation("Build"),pickupable(false) {};
    virtual ~BuildOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class UnbuildOperation : public ScriptOperation
{
protected:
public:

    UnbuildOperation(): ScriptOperation("Unbuild") {};
    virtual ~UnbuildOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class BusyOperation : public ScriptOperation
{
protected:
    bool busy;
public:

    BusyOperation(bool busy): ScriptOperation(busy?"Busy":"Idle"),busy(busy) {};
    virtual ~BusyOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class CastOperation : public ScriptOperation
{
protected:
    csString spell;
    csString kFactor;

    CastOperation(const CastOperation* other);

public:
    CastOperation();
    virtual ~CastOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class ChangeBrainOperation : public ScriptOperation
{
protected:
    csString brain;

    ChangeBrainOperation(const ChangeBrainOperation* other);

public:
    ChangeBrainOperation();
    virtual ~ChangeBrainOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class ChaseOperation : public MovementOperation
{
protected:
    EID              targetEID;              
    float            offsetAngle;            
    csVector3        offsetDelta;            
    float            adaptivVelScale;               
    MathScript* calcAdaptivVelocity; 


    int              type;                   
    float            searchRange;            
    float            chaseRange;             

    csString         offsetAttribute;        
    float            offsetAngleMax;         
    float            sideOffset;             
    bool             offsetRelativeHeading;  
    csString         adaptivVelocityScript;  


    enum
    {
        NEAREST_ACTOR,   
        NEAREST_NPC,     
        NEAREST_PLAYER,  
        OWNER,           
        TARGET           
    };
    static const char* typeStr[];

    ChaseOperation(const ChaseOperation* other);

public:
    ChaseOperation();

    virtual ~ChaseOperation() {}

    csVector3 CalculateOffsetDelta(NPC* npc, const csVector3 &myPos, const iSector* mySector,
                                   const csVector3 &endPos, const iSector* endSector,
                                   float endRot) const;

    virtual bool GetEndPosition(NPC* npc, const csVector3 &myPos, const iSector* mySector,
                                csVector3 &endPos, iSector* &endSector);

    virtual gemNPCActor* UpdateChaseTarget(NPC* npc, const csVector3 &myPos, const iSector* mySector);

    virtual bool UpdateEndPosition(NPC* npc, const csVector3 &myPos, const iSector* mySector,
                                   csVector3 &endPos, iSector* &endSector);

    virtual bool Load(iDocumentNode* node);

    virtual float GetOffset(NPC* npc) const;

    float AdaptivVelocity(NPC* npc, float distance);

    virtual float GetVelocity(NPC* npc);


    virtual ScriptOperation* MakeCopy();
};


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

class CopyLocateOperation : public ScriptOperation
{
protected:
    csString source;
    csString destination;
    unsigned int flags;
public:

    CopyLocateOperation(): ScriptOperation("CopyLocate"), flags(NPC::LOCATION_ALL) {};
    virtual ~CopyLocateOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class DeleteNPCOperation : public ScriptOperation
{
protected:
    DeleteNPCOperation(const DeleteNPCOperation* other);

public:
    DeleteNPCOperation();
    virtual ~DeleteNPCOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class MoveOperation : public ScriptOperation
{
protected:
    csString  action;
    float     duration;

    float     angle;

    // Instance temp variables. These dosn't need to be copied.
    float remaining;

    MoveOperation(const char*  n): ScriptOperation(n),remaining(0.0f)
    {
        duration = 0;
        ang_vel = 0;
        angle = 0;
    }
public:

    MoveOperation(): ScriptOperation("Move"),remaining(0.0f)
    {
        duration = 0;
        ang_vel = 0;
        angle = 0;
    }
    virtual ~MoveOperation() { }
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();

    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual OperationResult Advance(float timedelta,NPC* npc);
    virtual void InterruptOperation(NPC* npc);

};

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

class AutoMemorizeOperation : public ScriptOperation
{
protected:
    csString types;
    bool     enable;
public:

    AutoMemorizeOperation(): ScriptOperation("AutoMemorize"), enable(false) { }
    virtual ~AutoMemorizeOperation() { }
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();

    virtual OperationResult Run(NPC* npc,bool interrupted);
};

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

class CircleOperation : public MoveOperation
{
protected:
    float radius;
public:

    CircleOperation(): MoveOperation("Circle")
    {
        radius = 0.0f;
    }
    virtual ~CircleOperation() { }
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();

    virtual OperationResult Run(NPC* npc,bool interrupted);
};

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

class ControlOperation : public ScriptOperation
{
protected:
    bool control;  // Should this operation take or release control
public:

    ControlOperation(bool control): ScriptOperation("Control"), control(control) { }
    virtual ~ControlOperation() { }
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();

    virtual OperationResult Run(NPC* npc,bool interrupted);
};

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

class DebugOperation : public ScriptOperation
{
protected:
    int      level;
    csString exclusive;

public:

    DebugOperation(): ScriptOperation("Debug"),level(0) {};
    virtual ~DebugOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class DequipOperation : public ScriptOperation
{
protected:
    csString slot;

public:

    DequipOperation(): ScriptOperation("Dequip") {};
    virtual ~DequipOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class WorkOperation : public ScriptOperation
{
protected:
    csString type;
    csString resource; 

public:

    WorkOperation(): ScriptOperation("Work") {};
    virtual ~WorkOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class DropOperation : public ScriptOperation
{
protected:
    csString slot;

public:

    DropOperation(): ScriptOperation("Drop") {};
    virtual ~DropOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class EatOperation : public ScriptOperation
{
protected:
    csString resource;

public:

    EatOperation(): ScriptOperation("Eat") {};
    virtual ~EatOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class EmoteOperation : public ScriptOperation
{
protected:
    csString cmd; 

public:

    EmoteOperation(): ScriptOperation("Emote") {};
    virtual ~EmoteOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class EquipOperation : public ScriptOperation
{
protected:
    csString item;
    csString slot;
    int      count; // Number of items to pick up from a stack

public:

    EquipOperation(): ScriptOperation("Equip"),count(0) {};
    virtual ~EquipOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class HateListOperation : public ScriptOperation
{
protected:
    enum
    {
        MAX_HATE = 0x0001,
        MIN_HATE = 0x0002,
        ABS_HATE = 0x0004,
        DELTA_HATE = 0x0008,
        HATE_PERCEPTION = 0x0010  
    };

    unsigned int flags;           
    float        maxHate;         
    float        minHate;         
    float        absoluteHate;    
    float        deltaHate;       
public:

    HateListOperation(): ScriptOperation("HateList"), flags(0),maxHate(0.0),minHate(0.0),absoluteHate(0.0),deltaHate(0.0) {};
    virtual ~HateListOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};


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

class InvisibleOperation : public ScriptOperation
{
public:

    InvisibleOperation(): ScriptOperation("Invisible") {};
    virtual ~InvisibleOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class LocateOperation : public ScriptOperation
{
protected:
    // Instance variables
    bool        staticLocated;
    NPC::Locate storedStaticLocated;

    // Operation parameters
    csString  object;
    float     range;
    bool      static_loc;
    bool      random;
    csString  locateOutsideRegion; 
    bool      locateInvisible;     
    bool      locateInvincible;    
    csString  destination;         


public:
    LocateOperation();
    LocateOperation(const LocateOperation* other);
    virtual ~LocateOperation() { }

    Waypoint* CalculateWaypoint(NPC* npc, csVector3 located_pos, iSector* located_sector, float located_range);

    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
private:
};

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

class LoopBeginOperation : public ScriptOperation
{
public:
    int iterations;

public:

    LoopBeginOperation(): ScriptOperation("BeginLoop")
    {
        iterations=0;
    }
    virtual ~LoopBeginOperation() { }

    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class LoopEndOperation : public ScriptOperation
{
protected:
    int loopback_op;
    int current;
    int iterations;

public:

    LoopEndOperation(int which,int iterations): ScriptOperation("LoopEnd")
    {
        loopback_op = which;
        this->iterations = iterations;
        current = 0;
    }
    virtual ~LoopEndOperation() { }
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class MeleeOperation : public ScriptOperation
{
protected:
    float        seek_range, melee_range;
    gemNPCActor* attacked_ent;
    csString     attackOutsideRegion;  
    bool         attackInvisible;
    bool         attackInvincible;
    csString     attack_type;
    csString     stance;
    csString     attackMostHatedTribeTarget; 


public:

    MeleeOperation(): ScriptOperation("Melee"),
        attackInvisible(false),attackInvincible(false)
    {
        attacked_ent=NULL;
        seek_range=0;
        melee_range=0;
    }
    virtual ~MeleeOperation() {}

    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();

    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual OperationResult Advance(float timedelta,NPC* npc);
    virtual void InterruptOperation(NPC* npc);
};

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

class MemorizeOperation : public ScriptOperation
{
protected:

public:

    MemorizeOperation(): ScriptOperation("Memorize") {};
    virtual ~MemorizeOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

// MoveOperation - Definition has been moved before the first user of this
//                 class as a base class.

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

class MovePathOperation : public ScriptOperation
{
protected:
    // Parameters
    csString           anim;
    csString           pathname;
    psPath::Direction  direction;

    // Internal variables
    psPath*            path;
    psPathAnchor*      anchor;

public:

    MovePathOperation(): ScriptOperation("MovePath"), direction(psPath::FORWARD), path(0), anchor(0) { }
    virtual ~MovePathOperation()
    {
        delete anchor;
    }
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();

    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual OperationResult Advance(float timedelta,NPC* npc);
    virtual void InterruptOperation(NPC* npc);
};

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

class MoveToOperation : public MovementOperation
{
protected:
    csVector3 destPos;
    iSector*  destSector;

    csString  memoryCheck; 
    csString  action;
public:
    MoveToOperation();
    MoveToOperation(const MoveToOperation* other);
    virtual ~MoveToOperation() { }

    virtual bool GetEndPosition(NPC* npc, const csVector3 &myPos, const iSector* mySector,
                                csVector3 &endPos, iSector* &endSector);

    virtual bool UpdateEndPosition(NPC* npc, const csVector3 &myPos, const iSector* mySector,
                                   csVector3 &endPos, iSector* &endSector);

    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class NavigateOperation : public MovementOperation
{
protected:
    csString action;
    bool     forceEndPosition;

    float     endAngle;    
    iSector*  endSector;   
    csVector3 endPos;      

public:

    NavigateOperation();
protected:
    NavigateOperation(const NavigateOperation* other);
public:
    virtual ~NavigateOperation() {};

    virtual ScriptOperation* MakeCopy();

    virtual bool GetEndPosition(NPC* npc, const csVector3 &myPos, const iSector* mySector,
                                csVector3 &endPos, iSector* &endSector);

    virtual bool UpdateEndPosition(NPC* npc, const csVector3 &myPos, const iSector* mySector,
                                   csVector3 &endPos, iSector* &endSector);

    virtual bool Load(iDocumentNode* node);
};

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

class NOPOperation : public ScriptOperation
{
protected:
public:

    NOPOperation(): ScriptOperation("NOPE") {};
    virtual ~NOPOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class PerceptOperation : public ScriptOperation
{
protected:
    enum TargetType
    {
        SELF,
        ALL,
        TRIBE,
        TARGET
    };

    class DelayedPerceptOperationGameEvent : public psGameEvent
    {
    protected:
        NPC*       npc;
        Perception pcpt;
        TargetType target;
        float      maxRange;

    public:
        DelayedPerceptOperationGameEvent(int offsetTicks, NPC* npc, Perception &pcpt, TargetType target, float maxRange);
        virtual void Trigger();  // Abstract event processing function
        virtual csString ToString() const;
    };

    csString   perception; 
    csString   type;       
    TargetType target;     
    float      maxRange;   
    csString   condition;  
    csString   failedPerception; 
    csString   delayed;          

    MathScript* calcCondition; 
public:

    PerceptOperation() :
        ScriptOperation("Percept"),
        target(SELF),
        maxRange(0.0),
        calcCondition(0)
    {
    }
    virtual ~PerceptOperation() {}
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
    virtual bool CheckCondition(NPC* npc);
    static void TriggerEvent(NPC* npc, Perception &pcpt, TargetType target, float maxRange);
};

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

class PickupOperation : public ScriptOperation
{
protected:
    csString object;
    csString slot;
    int      count; // Number of items to pick up from a stack

public:

    PickupOperation(): ScriptOperation("Pickup"),count(0) {};
    virtual ~PickupOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class ReproduceOperation : public ScriptOperation
{
protected:
    csString tribeMemberType;
public:

    ReproduceOperation(): ScriptOperation("Reproduce") {};
    virtual ~ReproduceOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class ResurrectOperation : public ScriptOperation
{
protected:

public:

    ResurrectOperation(): ScriptOperation("Resurrect") {};
    virtual ~ResurrectOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class RewardOperation : public ScriptOperation
{
protected:
    csString resource; 
    int count;         

public:

    RewardOperation(): ScriptOperation("Reward"), count(0) {};
    virtual ~RewardOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class RotateOperation : public ScriptOperation
{
protected:
    enum
    {
        ROT_UNKNOWN,
        ROT_ABSOLUTE,               // Rotate to this world angle
        ROT_RELATIVE,               // Rotate delta angle from current npd heading
        ROT_TARGET,                 // Rotate to face target
        ROT_LOCATE_DESTINATION,     // Rotate to face located destination
        ROT_LOCATE_ROTATION,        // Rotate to face located rotatation
        ROT_RANDOM,                 // Rotate a random angle
        ROT_REGION,                 // Rotate to an angle within the region
        ROT_TRIBE_HOME              // Rotate to an angle within tribe home
    };
    int       op_type;              // Type of rotation. See enum above.
    float     min_range, max_range; // Min,Max values for random and region rotation
    float     delta_angle;          // Value to rotate for relative rotation

    float     target_angle;         // Calculated end rotation for every rotation and
    // input to absolute rotation
    float     angle_delta;          // Calculated angle that is needed to rotate to target_angle

    csString  action;               // Animation to use in the rotation

    // Instance temp variables. These dosn't need to be copied.
    float remaining;
public:

    RotateOperation(): ScriptOperation("Rotate")
    {
        vel=0;
        ang_vel=999;
        op_type=ROT_UNKNOWN;
        min_range=0;
        max_range=0;
        delta_angle=0;
        target_angle=0;
        angle_delta=0;
        remaining = 0.0;
    }
    virtual ~RotateOperation() { }
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();

    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual OperationResult Advance(float timedelta,NPC* npc);
    virtual void InterruptOperation(NPC* npc);

    float SeekAngle(NPC* npc, float targetYRot);           // Finds an angle which won't lead to a collision
};

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

class VelSourceOperation : public ScriptOperation
{
protected:
public:

    VelSourceOperation(): ScriptOperation("VelSource")
    {
    }
    virtual ~VelSourceOperation() { }
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
    virtual OperationResult Run(NPC* npc,bool interrupted);
};

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

class ProgressScriptOperation : public ScriptOperation
{
protected:
    csString scriptName; 

    // Instance temp variables. These dosn't need to be copied.

public:

    ProgressScriptOperation(): ScriptOperation("Script") {};
    virtual ~ProgressScriptOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class SequenceOperation : public ScriptOperation
{
protected:
    enum // Sequence commands, should use same values as in the psSequenceMessage
    {
        UNKNOWN = 0,
        START = 1,
        STOP = 2,
        LOOP = 3
    };

    csString sequenceName;
    int      cmd;    // See enum above
    int      count;  // Number of times to run the sequence

public:

    SequenceOperation(): ScriptOperation("Sequence"),cmd(UNKNOWN),count(0) {};
    virtual ~SequenceOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class SetBufferOperation : public ScriptOperation
{
protected:
    enum // Sequence commands, should use same values as in the psSequenceMessage
    {
        NPC_BUFFER = 0,
        TRIBE_BUFFER = 1
    };

    csString buffer;
    csString value;
    int      type;

public:

    SetBufferOperation(): ScriptOperation("SetBuffer"), type(NPC_BUFFER) {};
    virtual ~SetBufferOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class ShareMemoriesOperation : public ScriptOperation
{
protected:

public:

    ShareMemoriesOperation(): ScriptOperation("ShareMemories") {};
    virtual ~ShareMemoriesOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class SitOperation : public ScriptOperation
{
protected:
    bool sit; 

    // Instance temp variables. These dosn't need to be copied.
    float remaining;

public:

    SitOperation(bool sit): ScriptOperation("Sit"), sit(sit), remaining(0.0) {};
    virtual ~SitOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual OperationResult Advance(float timedelta,NPC* npc);
    virtual ScriptOperation* MakeCopy();
};

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

class TalkOperation : public ScriptOperation
{
protected:
    typedef psNPCCommandsMessage::PerceptionTalkType TalkType;

    csString talkText;   
    TalkType talkType;   
    bool     talkPublic; 
    bool     target;     
    csString command;    

public:

    TalkOperation(): ScriptOperation("Talk"),talkType(psNPCCommandsMessage::TALK_SAY),talkPublic(false),target(false) {};
    virtual ~TalkOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class TeleportOperation : public ScriptOperation
{
protected:

public:

    TeleportOperation(): ScriptOperation("Teleport") {};
    virtual ~TeleportOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class TransferOperation : public ScriptOperation
{
protected:
    csString item;
    int count;
    csString target;

public:

    TransferOperation(): ScriptOperation("Transfer"), count(0) {};
    virtual ~TransferOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class TribeHomeOperation : public ScriptOperation
{
protected:

public:

    TribeHomeOperation(): ScriptOperation("Tribe_Home") {};
    virtual ~TribeHomeOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class TribeTypeOperation : public ScriptOperation
{
protected:
    csString tribeType;
public:

    TribeTypeOperation(): ScriptOperation("Tribe_Type") {};
    virtual ~TribeTypeOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class VisibleOperation : public ScriptOperation
{
public:

    VisibleOperation(): ScriptOperation("Visible") {};
    virtual ~VisibleOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

class WaitOperation : public ScriptOperation
{
protected:
    csString duration;  
    csString random;    
    csString action;

    // Instance temp variables. These dosn't need to be copied.
    float remaining;

public:

    WaitOperation(): ScriptOperation("Wait"),remaining(0.0f)
    {
        duration=0;
    }
    virtual ~WaitOperation() { }

    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual OperationResult Advance(float timedelta,NPC* npc);
    virtual ScriptOperation* MakeCopy();
};

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

class WanderOperation : public ScriptOperation
{
protected:
    // Start of instance temp variables. These dosn't need to be copied.

    class WanderRouteFilter : public psPathNetwork::RouteFilter
    {
    public:
        WanderRouteFilter(WanderOperation*  parent):parent(parent) {};
        virtual bool Filter(const Waypoint* waypoint) const;
    protected:
        WanderOperation*  parent;
    };

    WanderRouteFilter wanderRouteFilter;

    csList<Edge*> edgeList;

    csList<Edge*>::Iterator   edgeIterator;
    Edge*                     currentEdge;              
    Edge::Iterator*           currentPathPointIterator; 
    psPathPoint*              currentPathPoint;         
    csVector3                 currentPointOffset;       
    float                     currentDistance;          
//    psPath::PathPointIterator pointIterator;

    // End of instance temp variables.

    // Start of operation parameters
    csString  action;
    bool      random;
    bool      undergroundValid,underground;
    bool      underwaterValid,underwater;
    bool      privValid,priv;
    bool      pubValid,pub;
    bool      cityValid,city;
    bool      indoorValid,indoor;
    bool      pathValid,path;
    bool      roadValid,road;
    bool      groundValid,ground;
    // End of operation parameters

    bool StartMoveTo(NPC* npc, psPathPoint* point);

    bool MoveTo(NPC* npc, psPathPoint* point);

    OperationResult CalculateEdgeList(NPC* npc);


    void SetPathPointIterator(Edge::Iterator* iterator);

public:

    WanderOperation();
    WanderOperation(const WanderOperation* other);
    virtual ~WanderOperation();

    virtual ScriptOperation* MakeCopy();


    void EdgeListClear()
    {
        edgeList.DeleteAll();
    }

    Edge* GetNextEdge(NPC* npc);


    psPathPoint* GetNextPathPoint(NPC* npc, bool &teleport);

    psPathPoint* GetCurrentPathPoint(NPC* npc);


    /* Utility function to calcualte distance from npc to destPoint.
     */
    static float DistanceToDestPoint(NPC* npc, const csVector3 &destPos, const iSector* destSector);


    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual OperationResult Advance(float timedelta,NPC* npc);
    virtual void InterruptOperation(NPC* npc);
    virtual bool Load(iDocumentNode* node);
};

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

class WatchOperation : public ScriptOperation
{
protected:
    float     watchRange;
    int       type;
    float     searchRange;       
    bool      watchInvisible;
    bool      watchInvincible;

    csWeakRef<gemNPCObject> watchedEnt;

    enum
    {
        NEAREST_ACTOR,   
        NEAREST_NPC,     
        NEAREST_PLAYER,  
        OWNER,
        TARGET
    };
    static const char*  typeStr[];

public:

    WatchOperation():ScriptOperation("Watch"),watchRange(0.0f),
        type(TARGET),searchRange(0.0f),watchInvisible(false),watchInvincible(false)
    {
        watchedEnt=NULL;
    }
    virtual ~WatchOperation() {}

    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();

    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual OperationResult Advance(float timedelta,NPC* npc);
    virtual void InterruptOperation(NPC* npc);

private:
    bool OutOfRange(NPC* npc);
};

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

class LootOperation : public ScriptOperation
{
protected:
    csString type;     

public:

    LootOperation(): ScriptOperation("Loot") {};
    virtual ~LootOperation() {};
    virtual OperationResult Run(NPC* npc,bool interrupted);
    virtual bool Load(iDocumentNode* node);
    virtual ScriptOperation* MakeCopy();
};

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

#endif