tribe.h

Go to the documentation of this file.

/*
* tribe.h
*
* Copyright (C) 2006 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.
*
*/
#ifndef __TRIBE_H__
#define __TRIBE_H__

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

#include <csgeom/vector3.h>
#include <iengine/sector.h>

//=============================================================================
// Project Includes
//=============================================================================
#include <util/psconst.h>
#include <util/psutil.h>
#include <util/remotedebug.h>

//=============================================================================
// Local Includes
//=============================================================================

class iResultRow;
class EventManager;
class NPC;
class gemNPCItem;
class Perception;
class gemNPCActor;
class Recipe;
class RecipeManager;
class RecipeTreeNode;
class EventManager;

#define TRIBE_UNLIMITED_SIZE   100

class Tribe : public ScopedTimerCB, public RemoteDebug
{
public:
    typedef csHash<csString,csString> BufferHash;

    typedef enum
    {
        ASSET_TYPE_ITEM,
        ASSET_TYPE_BUILDING,
        ASSET_TYPE_BUILDINGSPOT
    } AssetType;
    static const char* AssetTypeStr[];

    typedef enum
    {
        ASSET_STATUS_NOT_APPLICABLE,
        ASSET_STATUS_NOT_USED,
        ASSET_STATUS_INCONSTRUCTION,
        ASSET_STATUS_CONSTRUCTED
    } AssetStatus;
    static const char* AssetStatusStr[];

    struct Resource
    {
        int      id;                     
        csString name;
        csString nick;
        int      amount;
    };

    struct Asset
    {
        int                   id;
        AssetType             type;      
        csString              name;      
        uint32_t              itemUID;   
        csWeakRef<gemNPCItem> item;      
        int                   quantity;  
        csVector3             pos;       
        csString              sectorName;
        iSector*              sector;    
        AssetStatus           status;    

        void        Save();

        iSector*    GetSector();

        gemNPCItem* GetItem();
    };

    struct Memory
    {
        int       id;          
        csString  name;
        csVector3 pos;
        iSector*  sector;
        csString  sectorName;  
        float     radius;
        NPC*      npc;         

        iSector* GetSector();
    };

    struct MemberID
    {
        PID       pid;
        csString  tribeMemberType; 
    };

    struct CyclicRecipe
    {
        Recipe* recipe;     
        int     timeTotal;  
        int     timeLeft;   
    };

    Tribe(EventManager* eventmngr, RecipeManager* rm);

    virtual ~Tribe();

    bool Load(iResultRow &row);

    bool LoadMember(iResultRow &row);

    bool LoadResource(iResultRow &row);

    bool AddMember(PID pid, const char* tribeMemberType);

    void SaveResource(Resource* resource, bool newResource);

    bool CheckAttach(NPC* npc);

    bool AttachMember(NPC* npc, const char* tribeMemberType);

    bool HandleDeath(NPC* npc);

    int AliveCount() const;

    void HandlePerception(NPC* npc, Perception* perception);

    void AddResource(csString resource, int amount, csString nick = "");

    int CountResource(csString resource) const;

    void Advance(csTicks when,EventManager* eventmgr);

    int GetID()
    {
        return id;
    }
    const char* GetName()
    {
        return name.GetDataSafe();
    }
    size_t GetMemberIDCount()
    {
        return membersId.GetSize();
    }
    size_t GetMemberCount()
    {
        return members.GetSize();
    }
    NPC* GetMember(size_t i)
    {
        return members[i];
    }
    size_t GetResourceCount()
    {
        return resources.GetSize();
    }
    const Resource &GetResource(size_t n)
    {
        return resources[n];
    }
    csList<Memory*>::Iterator GetMemoryIterator()
    {
        csList<Memory*>::Iterator it(memories);
        return it;
    };
    csString GetNPCIdleBehavior()
    {
        return npcIdleBehavior;
    }
    csVector3 GetHomePosition()
    {
        return homePos;
    }
    iSector* GetHomeSector();
    csString GetHomeSectorName()
    {
        return homeSectorName;
    }

    int GetMaxSize() const;


    int GetReproductionCost() const;

    void GetHome(csVector3 &pos, float &radius, iSector* &sector);

    void SetHome(const csVector3 &pos, float radius, iSector* sector);

    bool CheckWithinBoundsTribeHome(NPC* npc, const csVector3 &pos, const iSector* sector);

    bool GetResource(NPC* npc, csVector3 startPos, iSector* startSector,
                     csVector3 &pos, iSector* &sector, float range, bool random);

    Tribe::Memory* GetResource(csString resourceName, NPC* npc);

    const char* GetNeededResource();

    const char* GetNeededResourceNick();

    const char* GetNeededResourceAreaType();

    float GetWealthResourceGrowth() const;

    float GetWealthResourceGrowthActive() const;

    int GetWealthResourceGrowthActiveLimit() const;


    bool CanGrow() const;

    bool ShouldGrow() const;

    void Memorize(NPC* npc, Perception* perception);

    Memory* FindPrivMemory(csString name,const csVector3 &pos, iSector* sector, float radius, NPC* npc);

    Memory* FindMemory(csString name,const csVector3 &pos, iSector* sector, float radius);

    Memory* FindMemory(csString name);

    void AddMemory(csString name,const csVector3 &pos, iSector* sector, float radius, NPC* npc);

    void ShareMemories(NPC* npc);

    void SaveMemory(Memory* memory);

    bool LoadMemory(iResultRow &row);

    void ForgetMemories(NPC* npc);

    Memory* FindNearestMemory(const char* name,const csVector3 &pos, const iSector* sector, float range = -1.0, float* foundRange = NULL);

    Memory* FindRandomMemory(const char* name,const csVector3 &pos, const iSector* sector, float range = -1.0, float* foundRange = NULL);

    void TriggerEvent(Perception* pcpt, float maxRange=-1.0,
                      csVector3* basePos=NULL, iSector* baseSector=NULL);

    void SendPerception(const char* pcpt, csArray<NPC*> npcs);

    void SendPerception(const char* pcpt);

    gemNPCActor* GetMostHated(NPC* npc, float range, bool includeOutsideRegion,
                              bool includeInvisible, bool includeInvincible, float* hate=NULL);

    virtual void ScopedTimerCallback(const ScopedTimer* timer);


    float GetDeathRate()
    {
        return deathRate;
    }

    float GetResourceRate()
    {
        return resourceRate;
    }

    void SetRecipeManager(RecipeManager* rm)
    {
        recipeManager = rm;
    }

    Recipe* GetTribalRecipe();

    void UpdateRecipeData(int delta);

    void AddRecipe(Recipe* recipe, Recipe* parentRecipe, bool reqType = false);

    void AddCyclicRecipe(Recipe* recipe, int time);

    void DeleteCyclicRecipe(Recipe* recipe);

    void AddKnowledge(csString knowHow)
    {
        knowledge.Push(knowHow);
    }

    bool CheckKnowledge(csString knowHow);

    void SaveKnowledge(csString knowHow);

    void DumpKnowledge();

    void DumpRecipesToConsole();

    bool LoadNPCMemoryBuffer(const char* name, csArray<NPC*> npcs);

    void LoadNPCMemoryBuffer(Tribe::Memory* memory, csArray<NPC*> npcs);

    bool CheckMembers(const csString &type, int number);

    bool CheckResource(csString resource, int number);

    bool CheckAsset(Tribe::AssetType type, csString name, int number);

    size_t AssetQuantity(Tribe::AssetType type, csString name);

    void Build(NPC* npc, bool pickupable);

    void Unbuild(NPC* npc, gemNPCItem* building);

    void HandlePersistItem(gemNPCItem* item);

    csArray<NPC*> SelectNPCs(const csString &type, const char* number);

    csString GetBuffer(const csString &bufferName);

    void SetBuffer(const csString &bufferName, const csString &value);

    void ReplaceBuffers(csString &result);

    void ModifyWait(Recipe* recipe, int delta);

    void LoadAsset(iResultRow &row);

    void SaveAsset(Tribe::Asset* asset, bool deletion = false);

    void AddAsset(Tribe::AssetType type, csString name, gemNPCItem* item, int quantity, int id = -1);

    Tribe::Asset* AddAsset(Tribe::AssetType type, csString name, csVector3 position, iSector* sector, Tribe::AssetStatus status);

    void RemoveAsset(Tribe::Asset* asset);

    Asset* GetAsset(Tribe::AssetType type, csString name);

    Asset* GetAsset(Tribe::AssetType type, csString name, Tribe::AssetStatus status);

    Asset* GetAsset(Tribe::AssetType type, csString name, csVector3 where, iSector* sector);

    Asset* GetAsset(gemNPCItem* item);

    Asset* GetAsset(uint32_t itemUID);

    Asset* GetRandomAsset(Tribe::AssetType type, Tribe::AssetStatus status, csVector3 pos, iSector* sector, float range);

    Asset* GetNearestAsset(Tribe::AssetType type, Tribe::AssetStatus status, csVector3 pos, iSector* sector, float range, float* locatedRange = NULL);

    Asset* GetRandomAsset(Tribe::AssetType type, csString name, Tribe::AssetStatus status, csVector3 pos, iSector* sector, float range);

    Asset* GetNearestAsset(Tribe::AssetType type, csString name, Tribe::AssetStatus status, csVector3 pos, iSector* sector, float range, float* locatedRange = NULL);

    void DeleteAsset(csString name, int quantity);

    void DeleteAsset(csString name, csVector3 pos);

    void DumpAssets();

    void DumpBuffers();

    void ProspectMine(NPC* npc, csString resource, csString nick);

private:
    virtual void LocalDebugReport(const csString &debugString);

    virtual void RemoteDebugReport(uint32_t clientNum, const csString &debugString);

    void UpdateDeathRate();

    void UpdateResourceRate(int amount);

    int                       id;                               
    csString                  name;                             
    csArray<MemberID>         membersId;                        
    csArray<NPC*>             members;                          
    csArray<NPC*>             deadMembers;                      
    csArray<Resource>         resources;                        
    csArray<csString>         knowledge;                        
    csPDelArray<Asset>        assets;                           
    csArray<CyclicRecipe>     cyclicRecipes;                    
    RecipeTreeNode*           tribalRecipe;                     

    csVector3                 homePos;                          
    float                     homeRadius;                       
    csString                  homeSectorName;                   
    iSector*                  homeSector;                       

    int                       maxSize;
    BufferHash                tribeBuffer;                      
    csString                  wealthResourceName;
    csString                  wealthResourceNick;
    csString                  wealthResourceArea;
    float                     wealthResourceGrowth;
    float                     wealthResourceGrowthActive;
    int                       wealthResourceGrowthActiveLimit;
    float                     accWealthGrowth;                  
    int                       reproductionCost;
    csString                  npcIdleBehavior;                  
    csString                  wealthGatherNeed;
    csList<Memory*>           memories;

    csTicks                   lastGrowth;
    csTicks                   lastAdvance;


    float                     deathRate;                        
    float                     resourceRate;                     
    csTicks                   lastDeath;                        
    csTicks                   lastResource;                     

    EventManager*             eventManager;                     
    RecipeManager*            recipeManager;                    
};

#endif