psnpcdialog.h

Go to the documentation of this file.

/*
 * psnpcdialog.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_IMP_NPC_DIALOG__
#define __PS_IMP_NPC_DIALOG__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <cstypes.h>
#include <iutil/comp.h>
#include <iutil/eventh.h>
#include <csutil/scf.h>
#include <cstool/collider.h>
#include <ivaria/collider.h>

//=============================================================================
// Project Includes
//=============================================================================
#include "util/psconst.h"
#include "util/psstring.h"

#include <idal.h>


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

class gemNPC;
class NPCDialogDict;
class NpcResponse;
class GemActor;
class Client;

struct iObjectRegistry;

struct KnowledgeArea
{
    csString area;
    int      priority;

    bool operator==(KnowledgeArea &other)
    {
        return (priority==other.priority && area == other.area);
    };
    bool operator<(KnowledgeArea &other)
    {
        if(priority<other.priority)
        {
            return true;
        }
        else if(priority>other.priority)
        {
            return false;
        }
        // Priority is equal so check area.
        if(strcmp(area,other.area)<0)
        {
            return true;
        }
        else
        {
            return false;
        }
    };
};

class NpcTriggerSentence
{
protected:
    csArray<NpcTerm*> terms;  
    csString str;             

public:
    NpcTriggerSentence()  {};
    void AddToSentence(NpcTerm* next_word);
    size_t TermLength()
    {
        return terms.GetSize();
    }
    const csString &GetString();
    void operator=(NpcTriggerSentence &other)
    {
        terms = other.terms;
        str=other.str;
    }
    NpcTerm* &Term(size_t i)
    {
        return terms[i];
    }
};


class DialogHistory
{
protected:
    struct DialogHistoryEntry
    {
        int playerID;    
        int responseID;  
        csTicks when;    
    };
    csArray<DialogHistoryEntry> history;
    int counter;                          
public:
    DialogHistory()
    {
        counter=0;
    }

    void AddToHistory(int playerID, int responseID, csTicks when);
    bool EverSaid(int playerID, int responseID, csTicks &howLongAgo, int &times);
};
#define MAX_HISTORY_LEN 100

class psNPCDialog
{
protected:
    gemNPC* self;
    csArray<KnowledgeArea*> knowareas;

    psString antecedent_her,
             antecedent_him,
             antecedent_it,
             antecedent_them;
    iDataConnection* db;
    csRandomGen* randomgen;
    gemActor* currentplayer;
    Client* currentClient;
    DialogHistory dialogHistory;

    NpcResponse* FindResponse(csString &trigger,const char* text, int questID = -1);
    NpcResponse* FindResponseWithAllPrior(const char* area,const char* trigger, int questID = -1);
    bool CheckPronouns(psString &text);
    void UpdateAntecedents(NpcResponse* resp);
    void AddBadText(const char* text,const char* trigger);

protected:
    void CleanPunctuation(psString &str, bool cleanQMark = true);

    void FilterKnownTerms(const psString &text, NpcTriggerSentence &trigger, Client* client);

    NpcResponse* FindOrGeneralizeTrigger(Client* client,NpcTriggerSentence &trigger,
                                         csArray<int> &gen_terms, int word);


    NpcResponse* ErrorResponse(const psString &text, const char* trigger);
    NpcResponse* RepeatedResponse(const psString &text, NpcResponse* resp, csTicks when, int times);

public:
    psNPCDialog(gemNPC* npc);
    virtual ~psNPCDialog();

    bool Initialize(iDataConnection* db, PID npcID);
    bool Initialize(iDataConnection* db);
    bool LoadKnowledgeAreas(PID npcID);

    NpcResponse* Respond(const char* text,Client* client);

    NpcResponse* FindXMLResponse(Client* client, csString trigger, int questID = -1);

    bool AddWord(const char* word);
    bool AddSynonym(const char* word,const char* synonym);
    bool AddKnowledgeArea(const char* ka_name);
    bool AddResponse(const char* area,const char* words,const char* response,const char* minfaction);
    bool AssignNPCArea(const char* npcname,const char* areaname);

    void SubstituteKeywords(Client* player, csString &response) const;


    //    void AddNewTrigger( int databaseID );

    //    void AddNewResponse ( int databaseID );

    void DumpDialog();
};

class psDialogManager;

class psTriggerBlock;
class psAttitudeBlock;
class psSpecialResponse;
class psResponse;

class psDialogManager
{
public:
    void AddTrigger(psTriggerBlock* trigger);

    void AddSpecialResponse(psSpecialResponse* response);

    void PrintInfo();

    csArray<psTriggerBlock*> triggers;


    csArray<psSpecialResponse*> special;

    int GetPriorID(int internalID);

    csArray<int> triggerIDs;

    csArray<int> responseIDs;

    csString    area;

    bool WriteToDatabase();

    int  InsertResponse(csString &response);
    int  InsertResponseSet(psResponse &response);
    int  InsertTrigger(const char* trigger, const char* area, int maxAttitude,
                       int minAttitude, int responseID, int priorID, int questID);
};


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

class psSpecialResponse
{
public:
    psSpecialResponse(csRef<iDocumentNode> responseNode, int questID);

    csString type;        

    csString response;    

    int attMin;           

    int attMax;           

    int questID;
};


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

class psTriggerBlock
{
public:
    psTriggerBlock(psDialogManager* mgr)
    {
        manager = mgr;
        priorResponseID = 0;
        questID = -1;
    }

    csStringArray phraseList;

    csArray<psAttitudeBlock*> attitudes;

    psTriggerBlock()
    {
        priorResponseID = 0;
    }

    void Create(csRef<iDocumentNode> triggerNode, int questID);

    void SetPrior(int id)
    {
        priorResponseID = id;
    }

    int priorResponseID;              

    int databaseID;                   

    csString area;                    

    psDialogManager* manager;         

    int questID;                      
};


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

class psResponse
{
public:
    csStringArray responses;

    csString script;
    csString pronoun_him,
             pronoun_her,
             pronoun_it,
             pronoun_them;

    int givenID;              

    int databaseID;           

    int questID;              

};


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

class psAttitudeBlock
{
public:
    static int responseID;    

    psAttitudeBlock(psDialogManager* mgr)
    {
        manager = mgr;
        responseSet.givenID = ++responseID;
    }

    psResponse responseSet;    

    void Create(csRef<iDocumentNode> attitudeNode, int questID);

    int maxAttitude;           

    int minAttitude;           

    psDialogManager* manager;  
};

#endif