psquestprereqops.h

Go to the documentation of this file.

/*
 * psquest.h
 *
 * Copyright (C) 2005 Atomic Blue (info@planeshift.it, 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.
 *
 *
 * Contains all prerequisites for a quest to be active, example completion of another quest,
 * or certain skills/ranks
 */

#ifndef __PSQUESTPREREQOPS_H__
#define __PSQUESTPREREQOPS_H__

//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/refarr.h>
#include <csutil/refcount.h>

//=============================================================================
// Project Includes
//=============================================================================

#include "pstrait.h"

//=============================================================================
// Local Includes
//=============================================================================
#include "psattack.h"

class psCharacter;
class psQuest;
class psSkillInfo;
struct Faction;

class psQuestPrereqOp : public csRefCount
{
public:
    virtual ~psQuestPrereqOp() {};

    virtual bool Check(psCharacter* character) = 0;

    virtual csString GetScript();

    virtual csString GetScriptOp() = 0;

    virtual csPtr<psQuestPrereqOp> Copy() = 0;
};

class psQuestPrereqOpList: public psQuestPrereqOp
{
protected:
    csRefArray<psQuestPrereqOp> prereqlist;
public:

    virtual ~psQuestPrereqOpList() {}

    virtual void Push(csRef<psQuestPrereqOp> prereqOp);

    virtual void Insert(size_t n, csRef<psQuestPrereqOp> prereqOp);

};

class psQuestPrereqOpAnd: public psQuestPrereqOpList
{
public:

    virtual ~psQuestPrereqOpAnd() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};


class psQuestPrereqOpOr: public psQuestPrereqOpList
{
public:

    virtual ~psQuestPrereqOpOr() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpRequire: public psQuestPrereqOpList
{
    int min,max;
public:

    psQuestPrereqOpRequire(int min_required,int max_required);

    virtual ~psQuestPrereqOpRequire() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpNot: public psQuestPrereqOpList
{
public:

    virtual ~psQuestPrereqOpNot() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpQuestCompleted: public psQuestPrereqOp
{
protected:
    csWeakRef<psQuest> quest;
    csString name;

public:

    psQuestPrereqOpQuestCompleted(psQuest* quest):quest(quest) { GetQuestName(); };

    psQuestPrereqOpQuestCompleted(csString questName);

    virtual ~psQuestPrereqOpQuestCompleted() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
    
    virtual psQuest* GetQuest();
    
    virtual csString GetQuestName();
};

class psQuestPrereqOpQuestAssigned: public psQuestPrereqOp
{
protected:
    csWeakRef<psQuest> quest;
    csString questName; 
public:

    psQuestPrereqOpQuestAssigned(psQuest* quest):quest(quest) { GetQuestName(); };

    virtual ~psQuestPrereqOpQuestAssigned() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
    
    virtual psQuest* GetQuest();
    
    virtual csString GetQuestName();
};

class psQuestPrereqOpQuestCompletedCategory: public psQuestPrereqOp
{
protected:

    int min;

    int max;

    csString category;
public:

    psQuestPrereqOpQuestCompletedCategory(csString quest_category,
                                          int min_required,int max_required)
        : min(min_required),max(max_required),category(quest_category) {};

    virtual ~psQuestPrereqOpQuestCompletedCategory() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpFaction: public psQuestPrereqOp
{
protected:
    Faction* faction;

    int value;
    bool max;
public:

    psQuestPrereqOpFaction(Faction* faction, int value, bool max):faction(faction),value(value),max(max) {};

    virtual ~psQuestPrereqOpFaction() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpItem : public psQuestPrereqOp
{
protected:
    csString itemName;          
    csString categoryName;      
    bool includeInventory;      
    int amountMin;              
    int amountMax;              
    float qualityMin;           
    float qualityMax;           
    
public:

    psQuestPrereqOpItem(const char* itemName, const char* categoryName, bool includeInventory, int amountMin, int amountMax, float qualityMin, float qualityMax):
        itemName(itemName), categoryName(categoryName), includeInventory(includeInventory),
        amountMin(amountMin), amountMax(amountMax), qualityMin(qualityMin), qualityMax(qualityMax) {};

    virtual ~psQuestPrereqOpItem() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpActiveMagic : public psQuestPrereqOp
{
protected:
    csString activeMagic;

public:

    psQuestPrereqOpActiveMagic(const char* activeMagic):activeMagic(activeMagic) {};

    virtual ~psQuestPrereqOpActiveMagic() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpTrait : public psQuestPrereqOp
{
protected:
    csString traitName;
    PSTRAIT_LOCATION traitLocation;

public:

    psQuestPrereqOpTrait(const char* traitName, csString traitLocationString):traitName(traitName)
    {
        for(int position = PSTRAIT_LOCATION_NONE; position < PSTRAIT_LOCATION_COUNT; position++)
        {
            if((csString)psTrait::locationString[position] == traitLocationString)
            {
                traitLocation = (PSTRAIT_LOCATION) position;
                break;
            }
        }
        // TraitLocation = (PSTRAIT_LOCATION)1;

    };

    virtual ~psQuestPrereqOpTrait() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpRace : public psQuestPrereqOp
{
protected:
    csString race;

public:

    psQuestPrereqOpRace(const char* race):race(race) {};

    virtual ~psQuestPrereqOpRace() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpGender : public psQuestPrereqOp
{
protected:
    csString gender;

public:

    psQuestPrereqOpGender(const char* gender):gender(gender) {};

    virtual ~psQuestPrereqOpGender() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpKnownSpell : public psQuestPrereqOp
{
protected:
    csString spell;

public:

    psQuestPrereqOpKnownSpell(const char* spell):spell(spell) {};

    virtual ~psQuestPrereqOpKnownSpell() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpGuild : public psQuestPrereqOp
{
protected:
    csString guildtype;
    csString guildName;

public:

    psQuestPrereqOpGuild(const char* guildtype, const char* guildName):guildtype(guildtype),guildName(guildName) {};

    virtual ~psQuestPrereqOpGuild() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpMarriage : public psQuestPrereqOp
{
public:

    psQuestPrereqOpMarriage() {};

    virtual ~psQuestPrereqOpMarriage() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpAdvisorPoints : public psQuestPrereqOp
{
protected:
    int minPoints, maxPoints;
    csString type;

public:

    psQuestPrereqOpAdvisorPoints(int minPoints, int maxPoints, csString type):minPoints(minPoints),maxPoints(maxPoints),type(type) {};

    virtual ~psQuestPrereqOpAdvisorPoints() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpTimeOnline : public psQuestPrereqOp
{
protected:
    unsigned int minTime, maxTime;

public:

    psQuestPrereqOpTimeOnline(int minTime, int maxTime):minTime(minTime),maxTime(maxTime) {};

    virtual ~psQuestPrereqOpTimeOnline() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpTimeOfDay : public psQuestPrereqOp
{
protected:
    int minTime, maxTime;

public:

    psQuestPrereqOpTimeOfDay(int minTime, int maxTime):minTime(minTime),maxTime(maxTime) {};

    virtual ~psQuestPrereqOpTimeOfDay() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpVariable : public psQuestPrereqOp
{
protected:
    csString variableName;
    csString variableValue;
    double min, max;

public:

    psQuestPrereqOpVariable(const char* name)
        : variableName(name), min(0), max(0)
    {
    }
    psQuestPrereqOpVariable(const char* name, const char* value)
        : variableName(name), variableValue(value), min(0), max(0)
    {
    }
    psQuestPrereqOpVariable(const char* name, double minv, double maxv)
        : variableName(name), min(minv), max(maxv)
    {
    }
    psQuestPrereqOpVariable(const psQuestPrereqOpVariable& other)
        : variableName(other.variableName), variableValue(other.variableValue),
          min(other.min), max(other.max)
    {
    }

    virtual ~psQuestPrereqOpVariable() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpXor: public psQuestPrereqOpList
{
public:

    virtual ~psQuestPrereqOpXor() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psQuestPrereqOpSkill: public psQuestPrereqOp
{
protected:
    psSkillInfo* skill;

    int min;          
    int max;          
    bool allowBuffed; 
public:

    psQuestPrereqOpSkill(psSkillInfo* skill, unsigned int min, unsigned int max, bool allowBuffed):skill(skill),min(min),max(max),allowBuffed(allowBuffed) {};

    virtual ~psQuestPrereqOpSkill() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();

    virtual csPtr<psQuestPrereqOp> Copy();
};

class psPrereqOpAttackType: public psQuestPrereqOp
{
 protected:
     psAttackType* attackType; 

 public:

    psPrereqOpAttackType(psAttackType* attackType) : attackType(attackType) {}

    virtual ~psPrereqOpAttackType() {}

    virtual bool Check(psCharacter* character);

    virtual csString GetScriptOp();


    virtual csPtr<psQuestPrereqOp> Copy();

private:
    bool checkWeapon(psCharacter* character, int slot);

    
    bool checkWType(psCharacter* character, psItem* weapon);
};


class psPrereqOpStance: public psQuestPrereqOp
{
 protected:
     csString stance;

 public:

    psPrereqOpStance(csString stance):stance(stance){};

    virtual ~psPrereqOpStance() {}


    virtual bool Check(psCharacter * character);


    virtual csString GetScriptOp();



    virtual csPtr<psQuestPrereqOp> Copy();

};

#endif