perceptions.h

Go to the documentation of this file.

/*
* perceptions.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 __PERCEPTIONS_H__
#define __PERCEPTIONS_H__

//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/weakref.h>
#include <csutil/array.h>

//=============================================================================
// Library Includes
//=============================================================================
#include "util/psconst.h"
#include "net/npcmessages.h"
#include "gem.h"

class Reaction;
class NPC;
class Location;
struct iSector;

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

class Perception
{
protected:
    csString name;       

    csString type;       

public:
    Perception(const char* name):name(name) {}

    Perception(const char* name, const char* type):name(name),type(type) {}

    virtual ~Perception() {}

    virtual bool ShouldReact(Reaction* reaction,NPC* npc);

    virtual Perception* MakeCopy();

    virtual void ExecutePerception(NPC* npc,float weight);

    virtual gemNPCObject* GetTarget()
    {
        return NULL;
    }

    virtual const csString &GetName() const;

    const csString &GetType() const;

    void SetType(const char* type);

    virtual bool GetLocation(csVector3 &pos, iSector* &sector);

    virtual float GetRadius() const
    {
        return 0.0;
    }

    virtual csString ToString(NPC* npc);
};

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

class TimePerception : public Perception
{
protected:
    int gameHour,gameMinute,gameYear,gameMonth,gameDay;

public:
    TimePerception(int hour, int minute, int year, int month, int day)
        : Perception("time"), gameHour(hour),gameMinute(minute),gameYear(year),gameMonth(month),gameDay(day)  {    }
    virtual ~TimePerception() {}

    virtual bool ShouldReact(Reaction* reaction,NPC* npc);
    virtual Perception* MakeCopy();
    virtual csString ToString(NPC* npc);

    static void NormalizeReaction(Reaction* reaction);
};

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

class FactionPerception : public Perception
{
protected:
    int factionDelta;
    csWeakRef<gemNPCActor> player;

public:
    FactionPerception(const char* n,int d,gemNPCObject* p)
        : Perception(n), factionDelta(d), player((gemNPCActor*)p)  {    }
    virtual ~FactionPerception() {}

    virtual bool ShouldReact(Reaction* reaction,NPC* npc);
    virtual Perception* MakeCopy();
    virtual gemNPCObject* GetTarget()
    {
        return player;
    }
    virtual void ExecutePerception(NPC* npc,float weight);
};

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

class ItemPerception : public Perception
{
protected:
    csWeakRef<gemNPCObject> item;

public:
    ItemPerception(const char* n,gemNPCObject* i)
        : Perception(n), item(i)  {    }
    virtual ~ItemPerception() {}

    virtual Perception* MakeCopy();
    virtual gemNPCObject* GetTarget()
    {
        return item;
    }
};

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

class LocationPerception : public Perception
{
protected:
    Location* location;

public:
    LocationPerception(const char* n, const char* type, Location* location, iEngine* engine)
        : Perception(n,type), location(location), engine(engine)  {}
    virtual ~LocationPerception() {}

    virtual Perception* MakeCopy();
    virtual bool GetLocation(csVector3 &pos, iSector* &sector);
    virtual float GetRadius() const;

private:
    iEngine* engine;
};

class PositionPerception : public Perception
{
protected:
    InstanceID instance;
    iSector* sector;
    csVector3 pos;
    float yrot;

    float radius;

public:
    PositionPerception(const char* n, const char* type,InstanceID &instance, iSector* sector, csVector3 &pos, float yrot, float radius)
        : Perception(n,type), instance(instance), sector(sector), pos(pos), yrot(yrot), radius(radius)  {}
    virtual ~PositionPerception() {}

    virtual Perception* MakeCopy();
    virtual bool GetLocation(csVector3 &pos, iSector* &sector);
    virtual float GetRadius() const;
};

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

class AttackPerception : public Perception
{
protected:
    csWeakRef<gemNPCActor> attacker;

public:
    AttackPerception(const char* n,gemNPCObject* attack)
        : Perception(n), attacker((gemNPCActor*) attack) { }

    virtual Perception* MakeCopy();
    virtual void ExecutePerception(NPC* npc,float weight);
    virtual gemNPCObject* GetTarget()
    {
        return attacker;
    }
};

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

class GroupAttackPerception : public Perception
{
protected:
    csWeakRef<gemNPCObject> attacker;
    csArray<gemNPCObject*> attacker_ents;
    csArray<int> bestSkillSlots;

public:
    GroupAttackPerception(const char* n,csArray<gemNPCObject*> &ents, csArray<int> &slots)
        : Perception(n), attacker_ents(ents), bestSkillSlots(slots) { }

    virtual Perception* MakeCopy();
    virtual void ExecutePerception(NPC* npc,float weight);
};

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

class DamagePerception : public Perception
{
protected:
    csWeakRef<gemNPCActor> attacker;
    float damage;

public:
    DamagePerception(const char* n,gemNPCObject* attack,float dmg)
        : Perception(n), attacker((gemNPCActor*)attack), damage(dmg) { }

    virtual Perception* MakeCopy();
    virtual void ExecutePerception(NPC* npc,float weight);
    virtual gemNPCObject* GetTarget()
    {
        return attacker;
    }
};

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

class SpellPerception : public Perception
{
protected:
    csWeakRef<gemNPCActor> caster;
    csWeakRef<gemNPCActor> target;
    float       spell_severity;

public:
    SpellPerception(const char* name,gemNPCObject* caster,gemNPCObject* target, const char* spell_type, float severity);

    virtual bool ShouldReact(Reaction* reaction,NPC* npc);
    virtual Perception* MakeCopy();
    virtual gemNPCObject* GetTarget()
    {
        return caster;
    }
    virtual void ExecutePerception(NPC* npc,float weight);
};

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

class DeathPerception : public Perception
{
protected:
    EID who;

public:
    DeathPerception(EID ent_id)
        : Perception("death"), who(ent_id) { }

    virtual Perception* MakeCopy();
    virtual void ExecutePerception(NPC* npc,float weight);
};

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

class InventoryPerception : public Perception
{
protected:
    csVector3 pos;
    iSector* sector;
    float     radius;
    int       count;

public:
    InventoryPerception(const char* n,const char* t,const int c, const csVector3 &p, iSector* s, float r)
        : Perception(n), pos(p), radius(r), count(c)
    {
        type = t;
        sector = s;
    }

    virtual Perception* MakeCopy();
    virtual bool GetLocation(csVector3 &pos, iSector* &sector)
    {
        pos = this->pos;
        sector = this->sector;
        return true;
    }

    virtual float GetRadius() const
    {
        return radius;
    }
    virtual int GetCount() const
    {
        return count;
    }

};

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

class OwnerCmdPerception : public Perception
{
protected:
    psPETCommandMessage::PetCommand_t command;
    csWeakRef<gemNPCObject> owner;
    csWeakRef<gemNPCObject> pet;
    csWeakRef<gemNPCActor> target;

public:
    OwnerCmdPerception(const char* n, psPETCommandMessage::PetCommand_t command, gemNPCObject* owner, gemNPCObject* pet, gemNPCObject* target);

    virtual bool ShouldReact(Reaction* reaction, NPC* pet);
    virtual Perception* MakeCopy();
    virtual void ExecutePerception(NPC* pet, float weight);
    virtual gemNPCObject* GetTarget()
    {
        return target;
    }
    static csString BuildName(psPETCommandMessage::PetCommand_t command);
};

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

class OwnerActionPerception : public Perception
{
protected:
    int action;
    csWeakRef<gemNPCObject> owner;
    csWeakRef<gemNPCObject> pet;

public:
    OwnerActionPerception(const char* n, int action, gemNPCObject* owner, gemNPCObject* pet);

    virtual bool ShouldReact(Reaction* reaction, NPC* pet);
    virtual Perception* MakeCopy();
    virtual void ExecutePerception(NPC* pet, float weight);
};

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

class NPCCmdPerception : public Perception
{
protected:
    NPC* self;

public:
    NPCCmdPerception(const char* command, NPC* self);

    virtual bool ShouldReact(Reaction* reaction, NPC* npc);
    virtual Perception* MakeCopy();
};

#endif