dictionary.h

Go to the documentation of this file.

/*
 * dictionary.h
 *
 * Copyright (C) 2001 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 PS_DICTIONARY_
#define PS_DICTIONARY_

//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/csstring.h>
//#include <csutil/ref.h>
#include <csutil/refcount.h>
#include <csutil/parray.h>
#include <csutil/hash.h>
#include <csutil/redblacktree.h>

//=============================================================================
// Project Includes
//=============================================================================
#include "rpgrules/psmoney.h"

#include "../tools/wordnet/wn.h"

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

class NpcTerm;
class NpcTriggerGroupEntry;
class NpcTrigger;
class NpcResponse;
class NpcDialogMenu;
class psSkillInfo;
class gemNPC;
class gemActor;
class Client;
class psQuest;
class psCharacter;
class MathScript;

struct iDocumentNode;
struct Faction;

#define MAX_RESP 5

template<typename K, typename K2> class NpcTriggerOrdering : public CS::Container::RedBlackTreeOrderingTotal<NpcTrigger,NpcTrigger>
{
public:
    NpcTriggerOrdering(NpcTrigger* const &a, NpcTrigger* const &b) : CS::Container::RedBlackTreeOrderingTotal<NpcTrigger,NpcTrigger>(*a,*b)
    {
    }
};

class NPCDialogDict
{
protected:
    typedef csRedBlackTree<NpcTrigger*, CS::Container::DefaultRedBlackTreeAllocator<NpcTrigger*>, NpcTriggerOrdering> NpcTriggerTree;
    csHash<NpcTerm*, csString>         phrases;
    csHash<NpcTriggerGroupEntry*, csString> trigger_groups;
    csHash<NpcTriggerGroupEntry*>      trigger_groups_by_id;
    NpcTriggerTree                     triggers;
    csHash<NpcTrigger*>                trigger_by_id;
    csHash<NpcResponse*>               responses;
    csHash<bool, csString>             disallowed_words;
    csHash<csString,csString>          knowledgeAreas;  

    csHash<NpcDialogMenu*,csString>    initial_popup_menus;
    csHash<NpcDialogMenu*>             initial_popup_menus_by_quest_id;

    int dynamic_id;

    bool LoadSynonyms(iDataConnection* db);
    bool LoadTriggerGroups(iDataConnection* db);
    bool LoadTriggers(iDataConnection* db);
    bool LoadResponses(iDataConnection* db);
    bool LoadDisallowedWords(iDataConnection* db);

    void AddWords(csString &trigger);

    NpcTerm* AddTerm(const char* term);

    int AddTriggerGroupEntry(int id,const char* txt, int equivID);
    csArray<NpcTrigger*> ParseMultiTrigger(NpcTrigger* parsetrig);

public:
    NPCDialogDict();
    virtual ~NPCDialogDict();

    bool Initialize(iDataConnection* db);

    bool FindKnowledgeArea(const csString &name);

    NpcTerm* FindTerm(const char* term);

    NpcTerm* FindTermOrSynonym(const csString &term);

    NpcResponse* FindResponse(gemNPC* npc,
                              const char* area,
                              const char* trigger,
                              int faction,
                              int priorresponse,
                              Client* client,
                              int questID = -1);

    NpcResponse* FindResponse(int responseID);

    bool AddTrigger(iDataConnection* db, int databaseID, int responseID);

    bool CheckForTriggerGroup(csString &trigger);

    void AddResponse(iDataConnection* db, int databaseID);

    NpcResponse* AddResponse(const char* response_text,
                             const char* pronoun_him,
                             const char* pronoun_her,
                             const char* pronoun_it,
                             const char* pronoun_them,
                             const char* npc_name,
                             int &new_id,
                             psQuest* quest,
                             const char* audio_path);

    NpcResponse* AddResponse(const char* script);

    NpcTrigger* AddTrigger(const char* k_area,
                           const char* mytrigger,
                           int prior_response,
                           int trigger_response);

    void DeleteTriggerResponse(NpcTrigger* trigger, int responseID);

    NpcDialogMenu* FindMenu(const char* name);

    void AddMenu(const char* name, NpcDialogMenu* menu);
    
    void AddMenu(NpcDialogMenu* menu);
    
    void DeleteMenusForQuest(psQuest* quest);
    
    void RemoveEmptyMenu(NpcDialogMenu* menu);

    void Print(const char* area);
};

class NpcTerm
{
    SynsetPtr hypernymSynNet;

    csArray<const char*> hypernyms;

    void BuildHypernymList();

public:

    csString term;

    NpcTerm* synonym;


    NpcTerm(const char* term)
    {
        synonym     = NULL;
        hypernymSynNet = NULL;
        this->term = term;
        this->term.Downcase();
    }
    ~NpcTerm()
    {
        if(hypernymSynNet)
            free_syns(hypernymSynNet);
    }

    const char* GetInterleavedHypernym(size_t which);

    bool IsNoun();

    void Print();
};

class NpcTriggerGroupEntry
{
public:
    int id;
    csString text;
    NpcTriggerGroupEntry* parent;

    NpcTriggerGroupEntry(int i,const char* txt,NpcTriggerGroupEntry* myParent=0)
    {
        id = i;
        text = txt;
        parent = myParent;
    }
};

class NpcTrigger
{
public:
    int      id;
    csString area;
    csString trigger;
    int      priorresponseID;
    csArray<int> responseIDlist;
    //    int      questID;

    bool Load(iResultRow &row);

    bool HaveAvailableResponses(Client* client, gemNPC* npc, NPCDialogDict* dict, csArray<int>* availableResponseList = NULL, int questID = -1);

    int  GetRandomResponse(const csArray<int> &availableResponseList);

    bool operator==(const NpcTrigger &other) const;

    bool operator<=(const NpcTrigger &other) const;
};


class ResponseOperation
{
protected:
    csString name;
public:
    virtual ~ResponseOperation() {};
    virtual bool Load(iDocumentNode* node) = 0;
    virtual csString GetResponseScript() = 0;
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber) = 0;
    const char* GetName()
    {
        return name;
    }
    virtual bool IsPublic()
    {
        return false;
    }
};

class NpcDialogMenu
{
protected:
    struct DialogTrigger
    {
        unsigned int triggerID;         
        csString menuText;              
        csString trigger;               
        psQuest* quest;                 
        csRef<psQuestPrereqOp> prerequisite; 
        
        /* returns the quest title 
         * @return the quest title if quest is set, otherwise "unknown"
         */
        csString GetQuestTitle();
        
        DialogTrigger() : quest(NULL) {}
    };

public:

    csArray<DialogTrigger> triggers;    

    NpcDialogMenu();

    void AddTrigger(const csString &menuText, const csString &trigger, psQuest* quest, psQuestPrereqOp* script=NULL);
    void Add(NpcDialogMenu* add);
    void DeleteAllMenusOfQuest(psQuest* quest);
    void ShowMenu(Client* client,csTicks delay, gemNPC* npc);
    void SetPrerequisiteScript(psQuestPrereqOp* script);
};

class NpcResponse
{
public:
    int      id;                 
    csString response[MAX_RESP]; 

    csString him,her,it,them;    
    csString triggerText;        
    csString voiceAudioPath[MAX_RESP];   
    int type;                    
    psQuest* quest;              
    int active_quest;            
    csTicks timeDelay;           
    csPDelArray<ResponseOperation> script;  
    csRef<psQuestPrereqOp> prerequisite; 
    NpcDialogMenu* menu;                

    enum
    {
        VALID_RESPONSE,
        ERROR_RESPONSE
    };

    NpcResponse();
    virtual ~NpcResponse();

    bool Load(iResultRow &row);

    void SetActiveQuest(int max);
    int  GetActiveQuest()
    {
        return active_quest;
    }

    const char* GetResponse(int &number);
    const char* GetResponse()
    {
        int number = 0;
        return GetResponse(number);
    }

    const char* GetVoiceFile(int &number)
    {
        return voiceAudioPath[number];
    }

    bool HasPublicResponse();
    bool ParseResponseScript(const char* xmlstr,bool insertBeginning=false);

    csTicks ExecuteScript(gemActor* player, gemNPC* target);
    csString GetResponseScript();

    // This is used so that the popup menu and the subsequent response can share the same filtering criteria
    psQuestPrereqOp* GetPrerequisiteScript()
    {
        return prerequisite;
    }

    bool ParsePrerequisiteScript(const char* xmlstr,bool insertBeginning=false);

    bool AddPrerequisite(psQuestPrereqOp* op, bool insertBeginning = false);

    bool CheckPrerequisite(psCharacter* character);
};

class SayResponseOp : public ResponseOperation
{
public:
    bool saypublic;
    csString* sayWhat;

    SayResponseOp(const char* name, bool is_public)
    {
        sayWhat=NULL;
        saypublic = is_public;
        this->name = name;
    }
    virtual ~SayResponseOp()
    {
        if(sayWhat) delete sayWhat;
    }
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
    virtual bool IsPublic()
    {
        return saypublic;
    }
};

class ActionResponseOp : public ResponseOperation
{
protected:
    bool actionMy,actionNarrate;
    bool actionpublic;
    csString anim;
    csString* actWhat;
public:
    ActionResponseOp(const char* actionName, bool my,bool narrate, bool is_public)
    {
        actionMy = my;
        actionNarrate=narrate;
        name = actionName;
        actionpublic = is_public;
        actWhat = NULL;
    }
    virtual ~ActionResponseOp()
    {
        if(actWhat) delete actWhat;
    }
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
    virtual bool IsPublic()
    {
        return actionpublic;
    }
};

class NPCCmdResponseOp : public ResponseOperation
{
protected:
    csString cmd;
public:
    NPCCmdResponseOp()
    {
        name = "npccmd";
    }
    virtual ~NPCCmdResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class psQuest;

class VerifyQuestCompletedResponseOp : public ResponseOperation
{
protected:
    psQuest* quest;        
    csString error_msg;    

public:
    VerifyQuestCompletedResponseOp()
    {
        name="verifyquestcompleted";
        quest=NULL;
    }
    virtual ~VerifyQuestCompletedResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};


class SetVariableResponseOp : public ResponseOperation
{
protected:
    csString variableName;  
    csString variableValue; 

public:
    SetVariableResponseOp()
    {
        name = "setvariable";
    }

    virtual ~SetVariableResponseOp() {};

    virtual bool Load(iDocumentNode* node);

    virtual csString GetResponseScript();

    virtual bool Run(gemNPC* who, gemActor* target, NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);

};


class UnSetVariableResponseOp : public ResponseOperation
{
protected:
    csString variableName; 

public:

    UnSetVariableResponseOp()
    {
        name = "unsetvariable";
    }

    virtual ~UnSetVariableResponseOp() {};

    virtual bool Load(iDocumentNode* node);

    virtual csString GetResponseScript();

    virtual bool Run(gemNPC* who, gemActor* target, NpcResponse* owner, csTicks &timeDelay, int &voiceNumber);
};


class VerifyQuestAssignedResponseOp : public ResponseOperation
{
protected:
    psQuest* quest;        
    csString error_msg;    

public:
    VerifyQuestAssignedResponseOp()
    {
        name="verifyquestassigned";
        quest=NULL;
    }
    VerifyQuestAssignedResponseOp(int quest);
    virtual ~VerifyQuestAssignedResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

/*
class FireEventResponseOp : public ResponseOperation
{
protected:
    csString event;
public:
    FireEventResponseOp() { name="fireevent"; }
    virtual ~FireEventResponseOp() {};
    virtual bool Load(iDocumentNode *node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC *who, Client *target,NpcResponse *owner,csTicks& timeDelay, int& voiceNumber);
};
*/

class VerifyQuestNotAssignedResponseOp : public ResponseOperation
{
protected:
    psQuest* quest;        
    csString error_msg;    

public:
    VerifyQuestNotAssignedResponseOp()
    {
        name="verifyquestnotassigned";
        quest=NULL;
    }
    VerifyQuestNotAssignedResponseOp(int quest);
    virtual ~VerifyQuestNotAssignedResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class AssignQuestResponseOp : public ResponseOperation
{
protected:
    psQuest* quest[MAX_RESP];  
    csString timeout_msg;  
    int num_quests;        

public:
    AssignQuestResponseOp()
    {
        name="assign";
        quest[0]=NULL;
    }
    virtual ~AssignQuestResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
    const char* GetTimeoutMsg()
    {
        return timeout_msg;
    }
    psQuest* GetQuest(int n)
    {
        return quest[n];
    }
    int      GetMaxQuests()
    {
        return num_quests;
    }
};

class AssignQuestSelectOp : public ResponseOperation
{
protected:
    AssignQuestResponseOp* quest_op;

public:
    AssignQuestSelectOp(AssignQuestResponseOp* questop)
    {
        name = "questselect";
        quest_op = questop;
    }
    virtual ~AssignQuestSelectOp() {};
    virtual bool Load(iDocumentNode* node)
    {
        return true;
    }
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};


class CheckQuestTimeoutOp : public ResponseOperation
{
protected:
    AssignQuestResponseOp* quest_op;

public:
    CheckQuestTimeoutOp(AssignQuestResponseOp* questop)
    {
        name = "checkquesttimeout";
        quest_op = questop;
    }
    virtual ~CheckQuestTimeoutOp() {};
    virtual bool Load(iDocumentNode* node)
    {
        return true;
    }
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class CompleteQuestResponseOp : public ResponseOperation
{
protected:
    psQuest* quest;
    csString error_msg;

public:
    CompleteQuestResponseOp()
    {
        name="complete";
        quest=NULL;
    }
    virtual ~CompleteQuestResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class UncompleteQuestResponseOp : public ResponseOperation
{
protected:
    psQuest* quest;
    csString error_msg;

public:
    UncompleteQuestResponseOp()
    {
        name="uncomplete";
        quest=NULL;
    }
    virtual ~UncompleteQuestResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class psItemStats;

class GiveItemResponseOp : public ResponseOperation
{
protected:
    psItemStats* itemstat;
    int count;
    float quality;

public:
    GiveItemResponseOp(): itemstat(NULL), count(1), quality(0)
    {
        name="give";
    }
    virtual ~GiveItemResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};


class FactionResponseOp : public ResponseOperation
{
protected:
    Faction* faction;
    int value;

public:
    FactionResponseOp()
    {
        name="faction";
    }
    virtual ~FactionResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class RunScriptResponseOp : public ResponseOperation
{
protected:
    csString scriptname;
    csString bindingsText;
    MathScript* bindings;

public:
    RunScriptResponseOp()
    {
        name = "run";
        bindings = NULL;
    }
    virtual ~RunScriptResponseOp();
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class TrainResponseOp : public ResponseOperation
{
protected:
    csString scriptname;
    psSkillInfo* skill;

public:
    TrainResponseOp()
    {
        name="train";
    }
    virtual ~TrainResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class GuildAwardResponseOp : public ResponseOperation
{
protected:
    int karma;
public:
    GuildAwardResponseOp()
    {
        name = "guild_award";
    }
    virtual ~GuildAwardResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class HireResponseOp : public ResponseOperation
{
protected:
    typedef enum 
    {
        HIRE_COMMAND_START,
        HIRE_COMMAND_TYPE,
        HIRE_COMMAND_MASTER,
        HIRE_COMMAND_CONFIRM,
        HIRE_COMMAND_SCRIPT,
        HIRE_COMMAND_RELEASE
    } HireCommand;
    
    HireCommand hireCommand;
    csString typeName;
    csString typeNPCType;
    PID masterNPCId;
public:
    HireResponseOp():
        hireCommand(HIRE_COMMAND_START)
    {
        name = "hire";
    }
    virtual ~HireResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

struct QuestRewardItem
{
    psItemStats* itemstat;
    int count;
    float quality;
};

class OfferRewardResponseOp : public ResponseOperation
{
protected:
    csArray<QuestRewardItem>  offer;
public:
    OfferRewardResponseOp()
    {
        name = "offer";
    }
    virtual ~OfferRewardResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class MoneyResponseOp : public ResponseOperation
{
protected:
    psMoney money;

public:
    MoneyResponseOp()
    {
        name = "money";
    }
    virtual ~MoneyResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class IntroduceResponseOp : public ResponseOperation
{
protected:
    csString targetName;
public:
    IntroduceResponseOp()
    {
        name = "introduce";
    }
    virtual ~IntroduceResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

class DoAdminCommandResponseOp : public ResponseOperation
{
protected:
    csString origCommandString, modifiedCommandString;
public:
    DoAdminCommandResponseOp()
    {
        name = "doadmincmd";
    }
    virtual ~DoAdminCommandResponseOp() {};
    virtual bool Load(iDocumentNode* node);
    virtual csString GetResponseScript();
    virtual bool Run(gemNPC* who, gemActor* target,NpcResponse* owner,csTicks &timeDelay, int &voiceNumber);
};

#endif