npcbehave.h

Go to the documentation of this file.

/*
* npcbehave.h
*
* Copyright (C) 2003 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.
*
*/

/* This file holds definitions for ALL global variables in the planeshift
* server, normally you should move global variables into the psServer class
*/
#ifndef __NPCBEHAVE_H__
#define __NPCBEHAVE_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csgeom/matrix3.h>
#include <csutil/array.h>
#include <iutil/document.h>

struct iSector;

//=============================================================================
// Library Includes
//=============================================================================
#include "util/eventmanager.h"
#include "util/gameevent.h"
#include "util/consoleout.h"
#include "util/pspath.h"

//=============================================================================
// Local Includes
//=============================================================================
#include "perceptions.h"
#include "walkpoly.h"
#include "npcoperations.h"

class ScriptOperation;
class Perception;
class Reaction;
class Behavior;
class NPC;
class EventManager;
class BehaviorSet;
class Waypoint;

class BehaviorSet
{
protected:
    csPDelArray<Behavior>  behaviors; 
    Behavior*              active;    

public:
    BehaviorSet();

    bool Add(Behavior* behavior);

    Behavior* Find(const char* name);

    void DeepCopy(BehaviorSet &other);

    void ClearState(NPC* npc);

    void UpdateNeeds(float delta, NPC* npc);

    Behavior* Schedule(NPC* npc);

    void Advance(csTicks delta, NPC* npc);

    void Execute(NPC* npc, bool forceRunScript);

    void Interrupt(NPC* npc);

    Behavior* GetCurrentBehavior()
    {
        return active;
    }

    void DumpBehaviorList(csString &output, NPC* npc);

    csString InfoBehaviors(NPC* npc);

    float GetHighestNeed(NPC* npc);

};


class NPCType
{
protected:
    NPC*                  npc;       
    csString              name;      
    csPDelArray<Reaction> reactions; 
    BehaviorSet           behaviors; 
    float                 ang_vel;   


    float                 vel;       


    ScriptOperation::VelSource             velSource; 

    csString              collisionPerception;   
    csString              outOfBoundsPerception; 
    csString              inBoundsPerception;    
    csString              fallingPerception;     

public:
    NPCType();
    NPCType(NPCType &other, NPC* npc);

    ~NPCType();
    void DeepCopy(NPCType &other);
    void ClearState(NPC* npc);

    bool Load(iDocumentNode* node);
    bool Load(iResultRow &node);
    const char* GetName()
    {
        return name.GetDataSafe();
    }

    Behavior* Find(const char* name)
    {
        return behaviors.Find(name);
    }

    void Advance(csTicks delta, NPC* npc);
    void Interrupt(NPC* npc);
    void FirePerception(NPC* npc,Perception* pcpt);

    void DumpBehaviorList(csString &output, NPC* npc)
    {
        behaviors.DumpBehaviorList(output, npc);
    }
    csString InfoBehaviors(NPC* npc)
    {
        return behaviors.InfoBehaviors(npc);
    }

    csString InfoReactions(NPC* npc);

    void DumpReactionList(csString &output, NPC* npc);

    Behavior* GetCurrentBehavior()
    {
        return behaviors.GetCurrentBehavior();
    }

    float GetHighestNeed(NPC* npc);

    float GetAngularVelocity(NPC* npc);

    float GetVelocity(NPC* npc);

    void SetVelSource(ScriptOperation::VelSource velSource, float vel);

    const csString &GetCollisionPerception() const;

    const csString &GetOutOfBoundsPerception() const;

    const csString &GetInBoundsPerception() const;

    const csString &GetFallingPerception() const;


private:
    void AddReaction(Reaction* reaction);

    void InsertReaction(Reaction* reaction);
};


class Behavior
{
public:
    // Used to indicate the result of the RunScript operation of a behavior.
    enum BehaviorResult
    {
        BEHAVIOR_NOT_COMPLETED,       
        BEHAVIOR_COMPLETED,           
        BEHAVIOR_WILL_COMPLETE_LATER, 
        BEHAVIOR_FAILED               
    };
protected:
    csString name;                      

    csPDelArray<ScriptOperation> sequence; 
    size_t   current_step;              
    size_t   stepCount;                 
    bool     loop;                      
    bool     isActive;                  
    bool     is_applicable_when_dead;
    float    need_decay_rate;           
    float    need_growth_rate;          
    float    completion_decay;          
    float    init_need;                 
    bool     resume_after_interrupt;    
    csString interruptPerception;       

    float    current_need;              
    float    new_need;                  

    bool     interrupted;               

    bool     minLimitValid;             
    float    minLimit;                  
    bool     maxLimitValid;             
    float    maxLimit;                  
    csString failurePerception;         

public:

    Behavior();
    Behavior(const char* n);
    Behavior(Behavior &other);

    virtual ~Behavior() { };

    const char* GetName()
    {
        return name;
    }

    void DeepCopy(Behavior &other);
    bool Load(iDocumentNode* node);

    bool LoadScript(iDocumentNode* node,bool top_level=true);

    void UpdateNeed(float delta, NPC* npc);
    BehaviorResult Advance(float delta, NPC* npc);
    float CurrentNeed()
    {
        return current_need;
    }
    float NewNeed()
    {
        return new_need;
    }

    void  CommitAdvance();

    void ApplyNeedDelta(NPC* npc, float deltaDesire);


    void ApplyNeedAbsolute(NPC* npc, float absoluteDesire);

    void SetIsActive(bool flag)
    {
        isActive = flag;
    }

    bool IsActive()
    {
        return isActive;
    }

    void SetCurrentStep(int step);
    size_t GetCurrentStep()
    {
        return current_step;
    }
    size_t GetLastStep()
    {
        return sequence.GetSize();
    }
    void ResetNeed()
    {
        current_need = new_need = init_need;
    }

    bool ApplicableToNPCState(NPC* npc);
    void DoCompletionDecay(NPC* npc);
    void StartScript(NPC* npc);
    void OperationCompleted(NPC* npc);
    void OperationFailed(NPC* npc);
    void SetStartStep();
    void InterruptScript(NPC* npc);
    bool IsInterrupted()
    {
        return interrupted;
    }
    void ClearInterrupted()
    {
        interrupted = false;
    }
    Behavior* SetCompletionDecay(float completion_decay)
    {
        this->completion_decay = completion_decay;
        return this;
    }

    inline bool operator==(const Behavior &other)
    {
        return (current_need == other.current_need &&
                name == other.name);
    }
    bool operator<(Behavior &other)
    {
        if(current_need > other.current_need)
            return true;
        if(current_need < other.current_need)
            return false;
        if(strcmp(name,other.name)>0)
            return true;
        return false;
    }

    // For testing purposes only.

    Behavior* SetDecay(float need_decay_rate)
    {
        this->need_decay_rate = need_decay_rate;
        return this;
    }
    Behavior* SetGrowth(float need_growth_rate)
    {
        this->need_growth_rate = need_growth_rate;
        return this;
    }
    Behavior* SetInitial(float init_need)
    {
        this->init_need = init_need;
        return this;
    }

    void Failure(NPC* npc, ScriptOperation* op);
};

class psGameObject
{
public:
    static void GetPosition(gemNPCObject* object, csVector3 &pos, float &yrot, iSector* &sector);

    static void GetPosition(gemNPCObject* object, csVector3 &pos, iSector* &sector);

    static void SetPosition(gemNPCObject* objecty, const csVector3 &pos, iSector* = NULL);
    static void SetRotationAngle(gemNPCObject* object, float angle);
    static void GetRotationAngle(gemNPCObject* object, float &yrot)
    {
        csVector3 pos;
        iSector* sector;
        GetPosition(object,pos,yrot,sector);
    }
    static float CalculateIncidentAngle(const csVector3 &pos, const csVector3 &dest);

    // Clamp the angle within 0 to 2*PI
    static void ClampRadians(float &target_angle);

    // Normalize angle within -PI to PI
    static void NormalizeRadians(float &target_angle);

    static csVector3 DisplaceTargetPos(const iSector* mySector, const csVector3 &myPos,
                                       const iSector* targetSector, const csVector3 &targetPos,
                                       float offset);
    static csVector3 DisplaceTargetPos(const iSector* mySector, const csVector3 &myPos,
                                       const iSector* targetSector, const csVector3 &targetPos,
                                       float offset, float angle);

    static float Calc2DDistance(const csVector3 &a, const csVector3 &b);

    static csString ReplaceNPCVariables(NPC* npc, const csString &object);

    static bool ReplaceNPCVariablesBool(NPC* npc, const csString &object);

};

#endif