text: //========= Copyright (c) 1996-2002, Valve LLC, All rights reserved. ==========
  //
  // Purpose:
  //
  // $NoKeywords: $
  //=============================================================================
  
  #ifndef AI_NAMESPACES_H
  #define AI_NAMESPACES_H
  
  class CStringRegistry;
  
  #if defined( _WIN32 )
  #pragma once
  #endif
  
  #define MAX_STRING_INDEX 9999
  const int GLOBAL_IDS_BASE = 1000000000; // decimal for debugging readability
  
  //-----------------------------------------------------------------------------
  
  inline bool AI_IdIsGlobal( int id )			{ return ( id >= GLOBAL_IDS_BASE || id == -1 ); }
  inline bool AI_IdIsLocal( int id )			{ return ( id < GLOBAL_IDS_BASE || id == -1 );  }
  inline int  AI_RemapToGlobal( int id )		{ return ( id != -1 ) ? id + GLOBAL_IDS_BASE : -1; }
  inline int  AI_RemapFromGlobal( int id )	{ return ( id != -1 ) ? id - GLOBAL_IDS_BASE : -1; }
  
  //-----------------------------------------------------------------------------
  // CAI_GlobalNamespace
  //
  // Purpose: Symbol table for all symbols accross a given namespace, a
  //			bi-directional mapping of "text" to global ID
  //
  
  class CAI_GlobalNamespace
  {
  public:
  	CAI_GlobalNamespace();
  	~CAI_GlobalNamespace();
  
  	void Clear();
  
  	void AddSymbol( const char *pszSymbol, int symbolID );
  	int NextGlobalBase() const;
  
  	const char *IdToSymbol( int symbolID ) const;
  	int SymbolToId( const char *pszSymbol ) const;
  
  private:
  	CStringRegistry * 	m_pSymbols;
  	int					m_NextGlobalBase;
  };
  
  //-----------------------------------------------------------------------------
  // CAI_LocalIdSpace
  //
  // Purpose: Maps per class IDs to global IDs, so that various classes can use
  //			the same integer in local space to represent different globally
  //			unique integers. Used for schedules, tasks, conditons and squads
  //
  
  class CAI_LocalIdSpace
  {
  public:
  	CAI_LocalIdSpace( bool fIsRoot = false );
  
  	bool Init( CAI_GlobalNamespace *pGlobalNamespace, CAI_LocalIdSpace *pParentIDSpace = NULL );
  	bool IsGlobalBaseSet() const { return ( m_globalBase != -1 ); }
  
  	bool AddSymbol( const char *pszSymbol, int localId, const char *pszDebugSymbolType = "", const char *pszDebugOwner = "" );
  
  	int GlobalToLocal( int globalID ) const;
  	int LocalToGlobal( int localID ) const;
  
  private:
  	bool IsLocalBaseSet() const	{ return ( m_localBase != MAX_STRING_INDEX );	}
  	int GetLocalBase() const	{ return m_localBase;  }
  	int GetGlobalBase() const	{ return m_globalBase; }
  	int GetLocalTop() const		{ return m_localTop;  }
  	int GetGlobalTop() const	{ return m_globalTop; }
  
  	bool SetLocalBase( int newBase );
  
  	// --------------------------------
  
  	int 					m_globalBase;
  	int 					m_localBase;
  	int 					m_localTop;
  	int 					m_globalTop;
  	CAI_LocalIdSpace *		m_pParentIDSpace;
  	CAI_GlobalNamespace *	m_pGlobalNamespace;
  };
  
  //-----------------------------------------------------------------------------
  //
  // Namespaces used by CAI_BaseNPC
  //
  //-----------------------------------------------------------------------------
  
  class CAI_GlobalScheduleNamespace
  {
  public:
  	void Clear()
  	{
  		m_ScheduleNamespace.Clear();
  		m_TaskNamespace.Clear();
  		m_ConditionNamespace.Clear();
  	}
  
  	void 		AddSchedule( const char *pszSchedule, int scheduleID );
  	const char *ScheduleIdToSymbol( int scheduleID ) const;
  	int 		ScheduleSymbolToId( const char *pszSchedule ) const;
  
  	void 		AddTask( const char *pszTask, int taskID );
  	const char *TaskIdToSymbol( int taskID ) const;
  	int 		TaskSymbolToId( const char *pszTask ) const;
  
  	void 		AddCondition( const char *pszCondition, int conditionID );
  	const char *ConditionIdToSymbol( int conditionID ) const;
  	int 		ConditionSymbolToId( const char *pszCondition ) const;
  
  private:
  	friend class CAI_ClassScheduleIdSpace;
  
  	CAI_GlobalNamespace m_ScheduleNamespace;
  	CAI_GlobalNamespace m_TaskNamespace;
  	CAI_GlobalNamespace m_ConditionNamespace;
  };
  
  //-------------------------------------
  
  class CAI_ClassScheduleIdSpace
  {
  public:
  	CAI_ClassScheduleIdSpace( bool fIsRoot = false )
  	 :	m_ScheduleIds( fIsRoot ),
  	 	m_TaskIds( fIsRoot ),
  	 	m_ConditionIds( fIsRoot )
  	{
  	}
  
  	bool Init( CAI_GlobalScheduleNamespace *pGlobalNamespace, CAI_ClassScheduleIdSpace *pParentIDSpace = NULL );
  
  	bool IsGlobalBaseSet() const;
  
  	bool AddSchedule( const char *pszSymbol, int localId, const char *pszDebugOwner = "" );
  	int ScheduleGlobalToLocal( int globalID ) const;
  	int ScheduleLocalToGlobal( int localID ) const;
  
  	bool AddTask( const char *pszSymbol, int localId, const char *pszDebugOwner = "" );
  	int TaskGlobalToLocal( int globalID ) const;
  	int TaskLocalToGlobal( int localID ) const;
  
  	bool AddCondition( const char *pszSymbol, int localId, const char *pszDebugOwner = "" );
  	int ConditionGlobalToLocal( int globalID ) const;
  	int ConditionLocalToGlobal( int localID ) const;
  
  private:
  	CAI_LocalIdSpace m_ScheduleIds;
  	CAI_LocalIdSpace m_TaskIds;
  	CAI_LocalIdSpace m_ConditionIds;
  };
  
  //-----------------------------------------------------------------------------
  
  inline void CAI_GlobalScheduleNamespace::AddSchedule( const char *pszSchedule, int scheduleID )
  {
  	m_ScheduleNamespace.AddSymbol( pszSchedule, scheduleID);
  }
  
  inline const char *CAI_GlobalScheduleNamespace::ScheduleIdToSymbol( int scheduleID ) const
  {
  	return m_ScheduleNamespace.IdToSymbol( scheduleID );
  }
  
  inline int CAI_GlobalScheduleNamespace::ScheduleSymbolToId( const char *pszSchedule ) const
  {
  	return m_ScheduleNamespace.SymbolToId( pszSchedule );
  }
  
  inline void CAI_GlobalScheduleNamespace::AddTask( const char *pszTask, int taskID )
  {
  	m_TaskNamespace.AddSymbol( pszTask, taskID);
  }
  
  inline const char *CAI_GlobalScheduleNamespace::TaskIdToSymbol( int taskID ) const
  {
  	return m_TaskNamespace.IdToSymbol( taskID );
  }
  
  inline int CAI_GlobalScheduleNamespace::TaskSymbolToId( const char *pszTask ) const
  {
  	return m_TaskNamespace.SymbolToId( pszTask );
  }
  
  inline void CAI_GlobalScheduleNamespace::AddCondition( const char *pszCondition, int conditionID )
  {
  	m_ConditionNamespace.AddSymbol( pszCondition, conditionID);
  }
  
  inline const char *CAI_GlobalScheduleNamespace::ConditionIdToSymbol( int conditionID ) const
  {
  	return m_ConditionNamespace.IdToSymbol( conditionID );
  }
  
  inline int CAI_GlobalScheduleNamespace::ConditionSymbolToId( const char *pszCondition ) const
  {
  	return m_ConditionNamespace.SymbolToId( pszCondition );
  }
  
  inline bool CAI_ClassScheduleIdSpace::Init( CAI_GlobalScheduleNamespace *pGlobalNamespace, CAI_ClassScheduleIdSpace *pParentIDSpace )
  {
  	return ( m_ScheduleIds.Init( &pGlobalNamespace->m_ScheduleNamespace, ( pParentIDSpace ) ? &pParentIDSpace->m_ScheduleIds : NULL ) &&
  			 m_TaskIds.Init( &pGlobalNamespace->m_TaskNamespace, ( pParentIDSpace ) ? &pParentIDSpace->m_TaskIds : NULL ) &&
  			 m_ConditionIds.Init( &pGlobalNamespace->m_ConditionNamespace, ( pParentIDSpace ) ? &pParentIDSpace->m_ConditionIds : NULL ) );
  }
  
  //-----------------------------------------------------------------------------
  
  inline bool CAI_ClassScheduleIdSpace::IsGlobalBaseSet() const
  {
  	return m_ScheduleIds.IsGlobalBaseSet();
  }
  
  inline bool CAI_ClassScheduleIdSpace::AddSchedule( const char *pszSymbol, int localId, const char *pszDebugOwner )
  {
  	return m_ScheduleIds.AddSymbol( pszSymbol, localId, "schedule", pszDebugOwner );
  }
  
  inline int CAI_ClassScheduleIdSpace::ScheduleGlobalToLocal( int globalID ) const
  {
  	return m_ScheduleIds.GlobalToLocal( globalID );
  }
  
  inline int CAI_ClassScheduleIdSpace::ScheduleLocalToGlobal( int localID ) const
  {
  	return m_ScheduleIds.LocalToGlobal( localID );
  }
  
  inline bool CAI_ClassScheduleIdSpace::AddTask( const char *pszSymbol, int localId, const char *pszDebugOwner )
  {
  	return m_TaskIds.AddSymbol( pszSymbol, localId, "task", pszDebugOwner );
  }
  
  inline int CAI_ClassScheduleIdSpace::TaskGlobalToLocal( int globalID ) const
  {
  	return m_TaskIds.GlobalToLocal( globalID );
  }
  
  inline int CAI_ClassScheduleIdSpace::TaskLocalToGlobal( int localID ) const
  {
  	return m_TaskIds.LocalToGlobal( localID );
  }
  
  inline bool CAI_ClassScheduleIdSpace::AddCondition( const char *pszSymbol, int localId, const char *pszDebugOwner )
  {
  	return m_ConditionIds.AddSymbol( pszSymbol, localId, "condition", pszDebugOwner );
  }
  
  inline int CAI_ClassScheduleIdSpace::ConditionGlobalToLocal( int globalID ) const
  {
  	return m_ConditionIds.GlobalToLocal( globalID );
  }
  
  inline int CAI_ClassScheduleIdSpace::ConditionLocalToGlobal( int localID ) const
  {
  	return m_ConditionIds.LocalToGlobal( localID );
  }
  
  //=============================================================================
  
  #endif // AI_NAMESPACES_H
  