272 lines
10 KiB
C++
272 lines
10 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// 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 Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
//#include "ai_entity_id.h" // this must be BEFORE the RYAI_AI_H test
|
|
|
|
#ifndef RYAI_AI_INSTANCE_H
|
|
#define RYAI_AI_INSTANCE_H
|
|
|
|
#include "child_container.h"
|
|
#include "server_share/msg_ai_service.h"
|
|
#include "ai_entity_matrix.h"
|
|
#include "ai_entity.h"
|
|
#include "continent.h"
|
|
#include "ai_grp.h"
|
|
#include "service_dependencies.h"
|
|
|
|
#include "sheets.h"
|
|
|
|
class CBot;
|
|
class CGroup;
|
|
class CManager;
|
|
|
|
template <class T>
|
|
class CAIEntityMatrix;
|
|
class CAIEntityMatrixIteratorTblRandom;
|
|
class CAIEntityMatrixIteratorTblLinear;
|
|
|
|
class CAIEntityPhysical;
|
|
class CAIEntity;
|
|
class CMgrPet;
|
|
class CManagerPlayer;
|
|
class CGroupNpc;
|
|
class CPersistentOfPhysical;
|
|
class CManagerPlayer;
|
|
class CAIS;
|
|
class CContinent;
|
|
class CCell;
|
|
class COutpostSquadFamily;
|
|
class CBotPlayer;
|
|
class CBotEasterEgg;
|
|
|
|
class CAIInstance
|
|
: public NLMISC::CDbgRefCount<CAIInstance>
|
|
, public NLMISC::CRefCount
|
|
, public CChild<CAIS>
|
|
, public CAIEntity
|
|
, public IManagerParent
|
|
, public CServiceEvent::CHandler
|
|
{
|
|
public:
|
|
CAIInstance(CAIS* owner);
|
|
virtual ~CAIInstance();
|
|
|
|
typedef CHashMap<NLMISC::TStringId, NLMISC::CDbgPtr<CNpcZone>, NLMISC::CStringIdHashMapTraits> TZoneList;
|
|
TZoneList zoneList;
|
|
void addZone(std::string const& zoneName, CNpcZone* zone);
|
|
void removeZone(std::string const& zoneName, CNpcZone* zone);
|
|
CNpcZone* getZone(NLMISC::TStringId zoneName);
|
|
// Trig Event if player in zone
|
|
void updateZoneTrigger(CBotPlayer* player);
|
|
|
|
// overloads for IManagerParent virtuals
|
|
CAIInstance* getAIInstance() const { return const_cast<CAIInstance*>(this); }
|
|
CCellZone* getCellZone() { return NULL; }
|
|
virtual std::string getIndexString() const;
|
|
virtual std::string getOneLineInfoString() const;
|
|
virtual std::vector<std::string> getMultiLineInfoString() const;
|
|
|
|
std::string getManagerIndexString(CManager const* manager) const;
|
|
|
|
void groupDead(CGroup* grp) { }
|
|
|
|
void serviceEvent(CServiceEvent const& info);
|
|
|
|
//-------------------------------------------------------------------
|
|
// classic init(), update() and release()
|
|
|
|
// the update routine called once per tick
|
|
// this is the routine that calls the managers' updates
|
|
void update();
|
|
|
|
//-------------------------------------------------------------------
|
|
// managing the set of managers
|
|
|
|
// factory for creating new managers and for adding them to the _managers map
|
|
CManager* newMgr(AITYPES::TMgrType type, uint32 alias, std::string const& name, std::string const& mapName, std::string const& filename);
|
|
|
|
// a method that parse a supposed know type of manager:group:bot hierarchy and return the element as CAIEntity.
|
|
CManager* tryToGetManager(char const* str);
|
|
CGroup* tryToGetGroup(char const* str);
|
|
|
|
CAIEntity* tryToGetEntity(char const* str, CAIS::TSearchType searchType);
|
|
|
|
// erase a manager (free resources, free id, etc, etc
|
|
// asserts if the id is invalid (<0 or >1023)
|
|
// displays a warning and returns cleanly if the id is unused
|
|
void deleteMgr(sint mgrId);
|
|
|
|
//-------------------------------------------------------------------
|
|
// the previous interfaces for searching the data structures for named objects are transfered in CAIEntityId
|
|
// as its one of their object behavior. a solution to build id directly was added.
|
|
CMgrPet* getPetMgr() { return _PetManager; }
|
|
CManagerPlayer* getPlayerMgr() { return _PlayerManager; }
|
|
|
|
//-------------------------------------------------------------------
|
|
// Interface to kami management
|
|
void registerKamiDeposit(uint32 alias, CGroupNpc* grp);
|
|
void unregisterKamiDeposit(uint32 alias);
|
|
|
|
//-------------------------------------------------------------------
|
|
// Interface to the vision management matrices
|
|
|
|
// read accessors for getting hold of the vision matrices and their associated iterator tables
|
|
CAIEntityMatrix<CPersistentOfPhysical>& playerMatrix() { return _PlayerMatrix; }
|
|
CAIEntityMatrix<CPersistentOfPhysical>& botMatrix() { return _BotMatrix; }
|
|
|
|
CAliasCont<CManager>& managers() { return _Managers; }
|
|
|
|
CCont<CContinent>& continents() { return _Continents; }
|
|
CCont<CContinent> const& continents() const { return _Continents; }
|
|
|
|
// Methods to retreive location in the dynamic system.
|
|
CContinent* locateContinentForPos(CAIVector const& pos);
|
|
CRegion* locateRegionForPos(CAIVector const& pos);
|
|
CCellZone* locateCellZoneForPos(CAIVector const& pos);
|
|
CCell* locateCellForPos(CAIVector const& pos);
|
|
|
|
|
|
//-------------------------------------------------------------------
|
|
// Mission name/alias retreiver
|
|
/** Add a mission name and alias info. If alias is already mapped to a mission name, replace the mapping.
|
|
* Many alias can be mapped to the same name, but a name can only belong to one alias.
|
|
*/
|
|
void addMissionInfo(std::string const& missionName, uint32 alias);
|
|
/** Return all mission alias that have a given mission name.
|
|
* n log n search
|
|
*/
|
|
void findMissionAlias(std::vector<uint32>& result, std::string const& missionName)
|
|
{
|
|
std::map<std::string, std::vector<uint32> >::iterator it(_MissionToAlias.find(missionName));
|
|
if (it != _MissionToAlias.end())
|
|
result.insert(result.end(), it->second.begin(), it->second.end());
|
|
}
|
|
/** Return the name of the mission for a given alias.
|
|
* Return an empty string if no mission have this alias.
|
|
* This search is not optimized, linar time search !
|
|
*/
|
|
std::string const& findMissionName(uint32 alias);
|
|
|
|
//-------------------------------------------------------------------
|
|
// group name/alias retreiver
|
|
void addGroupInfo(CGroup* grp);
|
|
void removeGroupInfo(CGroup* grp, CAliasTreeOwner* grpAliasTreeOwner);
|
|
CGroup* findGroup(uint32 alias);
|
|
void findGroup(std::vector<CGroup*>& result, std::string const& name);
|
|
|
|
/// Time warp management. This method is called when time as warped more than 600ms
|
|
bool advanceUserTimer(uint32 nbTicks);
|
|
|
|
bool spawn();
|
|
bool despawn();
|
|
|
|
uint32 getInstanceNumber() const { return _InstanceNumber; }
|
|
std::string const& getContinentName() const { return _ContinentName; }
|
|
std::string& getContinentName() { return _ContinentName; }
|
|
|
|
void initInstance(std::string const& continentName, uint32 instanceNumber);
|
|
|
|
/// Main squad family accessor
|
|
COutpostSquadFamily *getSquadFamily() { return _SquadFamily; }
|
|
|
|
/// Store mapping 'name:variant' -> squad to be used later by getSquadByVariantName()
|
|
void registerSquadVariant(const std::string& nameAndVariant, CGroupDesc<COutpostSquadFamily> *squad )
|
|
{
|
|
if ( ! _SquadVariantNameToGroupDesc.insert( std::make_pair( NLMISC::toLower( nameAndVariant ), squad ) ).second )
|
|
nlwarning( "Duplicate squad template / squad variant '%s'", nameAndVariant.c_str() );
|
|
}
|
|
|
|
/// Clear mapping 'name:variant' -> squad when it's not useful anymore
|
|
void clearSquadVariantNames()
|
|
{
|
|
_SquadVariantNameToGroupDesc.clear();
|
|
}
|
|
|
|
/// Get a squad by name:variant (works only during primitive parsing), or NULL if not found. Not case-sensitive.
|
|
CGroupDesc<COutpostSquadFamily> *getSquadByVariantName(const std::string& nameAndVariant)
|
|
{
|
|
std::map<std::string, NLMISC::CSmartPtr< CGroupDesc<COutpostSquadFamily> > >::iterator it = _SquadVariantNameToGroupDesc.find( NLMISC::toLower( nameAndVariant ) );
|
|
if ( it != _SquadVariantNameToGroupDesc.end() )
|
|
return (*it).second;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
CGroupNpc* eventCreateNpcGroup(uint nbBots, NLMISC::CSheetId const& sheetId, CAIVector const& pos, double dispersionRadius, bool spawnBots);
|
|
|
|
/// create a new easter egg
|
|
CBotEasterEgg* createEasterEgg(uint32 easterEggId, NLMISC::CSheetId const& sheetId, std::string const& botName, double x, double y, double z, double heading, const std::string& look);
|
|
/// destroy an easter egg
|
|
void destroyEasterEgg(uint32 easterEggId);
|
|
/// get an easter egg by ID
|
|
CBotEasterEgg* getEasterEgg(uint32 easterEggId);
|
|
|
|
private:
|
|
void sendInstanceInfoToEGS();
|
|
|
|
private:
|
|
/// @name AI service hierarchy
|
|
//@{
|
|
/// The set of continents
|
|
CCont<CContinent> _Continents;
|
|
/// the set of managers and the service's root alias description tree node
|
|
CAliasCont<CManager> _Managers;
|
|
//@}
|
|
|
|
/// The ai instance continent name (multi ai system)
|
|
std::string _ContinentName;
|
|
/// The ai instance number (multi ai system)
|
|
uint32 _InstanceNumber;
|
|
|
|
CAIEntity* tryToGetEntity(char const* str);
|
|
|
|
// we must share pets and players .. later :)
|
|
/// pet manager
|
|
CMgrPet* _PetManager;
|
|
/// player Manager.
|
|
CManagerPlayer* _PlayerManager;
|
|
/// event npc Manager.
|
|
CMgrNpc* _EventNpcManager;
|
|
/// easter egg manager
|
|
NLMISC::CRefPtr<CMgrNpc> _EasterEggManager;
|
|
|
|
/// easter egg group
|
|
NLMISC::CRefPtr<CGroupNpc> _EasterEggGroup;
|
|
|
|
/// map of kami groups by alias (for kami groups associated with deposits)
|
|
std::map<uint, CGroupNpc*> _KamiDeposits;
|
|
|
|
/// matrices used for vision generation and their associated iterator tables
|
|
CAIEntityMatrix<CPersistentOfPhysical> _PlayerMatrix;
|
|
CAIEntityMatrix<CPersistentOfPhysical> _BotMatrix;
|
|
|
|
// Mission name to alias container.
|
|
std::map<std::string, std::vector<uint32> > _MissionToAlias;
|
|
|
|
/// Group name and alias container.
|
|
std::map<std::string, std::vector<NLMISC::CDbgPtr<CGroup> > > _GroupFromNames;
|
|
std::map<uint32, NLMISC::CDbgPtr<CGroup> > _GroupFromAlias;
|
|
|
|
// Container for all the squad templates
|
|
NLMISC::CSmartPtr<COutpostSquadFamily> _SquadFamily;
|
|
|
|
// Squad look-up (only valid during primitive parsing)
|
|
std::map< std::string, NLMISC::CSmartPtr< CGroupDesc<COutpostSquadFamily> > > _SquadVariantNameToGroupDesc;
|
|
};
|
|
|
|
#endif
|