大改

csgo2/sdk/public/eiface.h

@@ -4,7 +4,10 @@
 #include "../tier1/bufferstring.h"
 #include "../convar/convar.hpp"
 #include "../protobuf-2.6.1/src/google/protobuf/message.h"
+#include "string_t.h"
 struct vis_info_t;
+struct string_t;
+
 class IHLTVServer;
 class IHLTVDirector;
 class CSteamID;
@@ -17,7 +20,111 @@ class CPlayerBitVec;
 class edict_t;
 class CGamestatsData;
 class KeyValues;
-class CGlobalVars;
+enum GlobalVarsUsageWarning_t
+{
+	GV_RENDERTIME_CALLED_DURING_SIMULATION,
+	GV_CURTIME_CALLED_DURING_RENDERING
+};
+enum MapLoadType_t
+{
+	MapLoad_NewGame = 0,
+	MapLoad_LoadGame,
+	MapLoad_Transition,
+	MapLoad_Background,
+};
+typedef void (*FnGlobalVarsWarningFunc)(GlobalVarsUsageWarning_t);
+
+//-----------------------------------------------------------------------------
+// Purpose: Global variables used by shared code
+//-----------------------------------------------------------------------------
+class CGlobalVarsBase
+{
+public:
+
+	CGlobalVarsBase();
+
+public:
+	// Absolute time (per frame still - Use Plat_FloatTime() for a high precision real time 
+	//  perf clock, but not that it doesn't obey host_timescale/host_framerate)
+	float realtime;
+	// Absolute frame counter - continues to increase even if game is paused
+	int framecount;
+
+	// Non-paused frametime
+	float absoluteframetime;
+	float absoluteframestarttimestddev;
+
+	int maxClients;
+
+	// zer0k: Command queue related
+	int unknown1;
+	int unknown2;
+
+	FnGlobalVarsWarningFunc m_pfnWarningFunc;
+
+	// Time spent on last server or client frame (has nothing to do with think intervals)
+	float frametime;
+
+	// Current time 
+	//
+	// On the client, this (along with tickcount) takes a different meaning based on what
+	// piece of code you're in:
+	// 
+	//   - While receiving network packets (like in PreDataUpdate/PostDataUpdate and proxies),
+	//     this is set to the SERVER TICKCOUNT for that packet. There is no interval between
+	//     the server ticks.
+	//     [server_current_Tick * tick_interval]
+	//
+	//   - While rendering, this is the exact client clock 
+	//     [client_current_tick * tick_interval + interpolation_amount]
+	//
+	//   - During prediction, this is based on the client's current tick:
+	//     [client_current_tick * tick_interval]
+	float curtime;
+	float rendertime;
+
+	// zer0k: Command queue + interpolation related 
+	float unknown3;
+	float unknown4;
+
+	bool m_bInSimulation;
+	bool m_bEnableAssertions;
+
+	// Simulation ticks - does not increase when game is paused
+	int tickcount;
+	// Simulation tick interval
+	float interval_per_tick;
+};
+
+inline CGlobalVarsBase::CGlobalVarsBase()
+{
+}
+
+class CGlobalVars : public CGlobalVarsBase
+{
+public:
+
+	CGlobalVars();
+
+public:
+
+	// Current map
+	string_t		mapname;
+	string_t		startspot;
+	MapLoadType_t	eLoadType;		// How the current map was loaded
+	bool mp_teamplay;
+
+	// current maxentities
+	int				maxEntities;
+
+	int				serverCount;
+};
+
+inline CGlobalVars::CGlobalVars() :
+	CGlobalVarsBase()
+{
+	serverCount = 0;
+}
 class CSharedEdictChangeInfo;
 class IAchievementMgr;
 class CCommandContext;

csgo2/sdk/public/iserver.h

@@ -0,0 +1,133 @@
+#pragma once
+#include "../sdk.h"
+class GameSessionConfiguration_t { };
+class IGameSpawnGroupMgr;
+struct EventServerAdvanceTick_t;
+struct EventServerPollNetworking_t;
+struct EventServerProcessNetworking_t;
+struct EventServerSimulate_t;
+struct EventServerPostSimulate_t;
+struct server_state_t;
+class IPrerequisite;
+class CServerChangelevelState;
+class ISource2WorldSession;
+class INetworkGameClient;
+class GameSessionConfiguration_t;
+typedef int HGameResourceManifest;
+struct SpawnGroupDesc_t;
+struct EngineLoopState_t;
+struct EventMapRegistrationType_t;
+class ILoopModeFactory;
+struct ActiveLoop_t;
+struct EventClientOutput_t;
+class ISwitchLoopModeStatusNotify;
+class IAddonListChangeNotify;
+
+enum ESpawnGroupUnloadOption
+{
+
+};
+
+class IConnectionlessPacketHandler
+{
+public:
+	virtual	~IConnectionlessPacketHandler(void) {};
+
+	virtual bool ProcessConnectionlessPacket(const void* addr, void* bf) = 0;	// process a connectionless packet
+};
+
+class INetworkGameServer : public IConnectionlessPacketHandler
+{
+public:
+	virtual	void	Init(const GameSessionConfiguration_t&, const char*) = 0;
+	virtual void	SetGameSpawnGroupMgr(IGameSpawnGroupMgr*) = 0;
+	virtual void	SetGameSessionManifest(HGameResourceManifest*) = 0;
+	virtual void	RegisterLoadingSpawnGroups(void*) = 0;
+	virtual void	Shutdown(void) = 0;
+	virtual void	AddRef(void) = 0;
+	virtual void	Release(void) = 0;
+	virtual CGlobalVars* GetGlobals(void) = 0;
+	virtual bool	IsActive(void) const = 0;
+	virtual void	SetServerTick(int tick) = 0;
+	virtual int		GetServerTick(void) const = 0;	// returns game world tick
+	virtual void	SetFinalSimulationTickThisFrame(int) = 0;
+	virtual int		GetMaxClients(void) const = 0; // returns current client limit
+	virtual float	GetTickInterval(void) const = 0; // tick interval in seconds
+	virtual void	ServerAdvanceTick(const EventServerAdvanceTick_t&) = 0;
+	virtual void	ServerPollNetworking(const EventServerPollNetworking_t&) = 0;
+	virtual void	ServerProcessNetworking(const EventServerProcessNetworking_t&) = 0;
+	virtual void	ServerSimulate(const EventServerSimulate_t&) = 0;
+	virtual void	ServerPostSimulate(const EventServerPostSimulate_t&) = 0;
+	virtual void	LoadSpawnGroup(const SpawnGroupDesc_t&) = 0;
+	virtual void	AsyncUnloadSpawnGroup(unsigned int, ESpawnGroupUnloadOption) = 0;
+	virtual void	PrintSpawnGroupStatus(void) const = 0;
+	virtual float	GetTimescale(void) const = 0; // returns the game time scale (multiplied in conjunction with host_timescale)
+	virtual bool	IsSaveRestoreAllowed(void) const = 0;
+	virtual void	SetMapName(const char* pszNewName) = 0;
+	virtual const char* GetMapName(void) const = 0; // current map name (BSP)
+	virtual const char* GetAddonName(void) const = 0;
+	virtual bool	IsBackgroundMap(void) const = 0;
+	virtual float	GetTime(void) const = 0;	// returns game world time
+	virtual int		GetMapVersion(void) const = 0;
+	virtual void	ActivateServer(void) = 0;
+	virtual void	PrepareForAssetLoad(void) = 0;
+	virtual int		GetServerNetworkAddress(void) = 0;
+	virtual SpawnGroupHandle_t FindSpawnGroupByName(const char* pszName) = 0;
+	virtual void	MakeSpawnGroupActive(SpawnGroupHandle_t) = 0;
+	virtual void	SynchronouslySpawnGroup(SpawnGroupHandle_t) = 0;
+	virtual void	SetServerState(server_state_t) = 0;
+	virtual void	SpawnServer(const char*) = 0;
+	virtual void	GetSpawnGroupLoadingStatus(SpawnGroupHandle_t) = 0;
+	virtual void	SetSpawnGroupDescription(SpawnGroupHandle_t, const char*) = 0;
+	virtual void* StartChangeLevel(const char*, const char* pszLandmark, void*) = 0;
+	virtual void	FinishChangeLevel(CServerChangelevelState*) = 0;
+	virtual bool	IsChangelevelPending(void) const = 0;
+	virtual void	GetAllLoadingSpawnGroups(void* pOut) = 0;
+	virtual void	PreserveSteamID(void) = 0;
+	virtual void	OnKickById(const CCommandContext& context, const CCommand& args) = 0;
+	virtual void	OnKickByName(const CCommandContext& context, const CCommand& args) = 0;
+};
+
+class IEngineService : public IAppSystem
+{
+public:
+	virtual void* GetServiceDependencies(void) = 0;
+	virtual const char* GetName(void) const = 0;
+	virtual bool		ShouldActivate(const char*) = 0;
+	virtual void		OnLoopActivate(const EngineLoopState_t& loopState, /*CEventDispatcher<CEventIDManager_Default>*/ void*) = 0;
+	virtual void		OnLoopDeactivate(const EngineLoopState_t& loopState, /*CEventDispatcher<CEventIDManager_Default>*/ void*) = 0;
+	virtual bool		IsActive(void) const = 0;
+	virtual void		SetActive(bool) = 0;
+	virtual void		SetName(const char* pszName) = 0;
+	virtual void		RegisterEventMap( /*CEventDispatcher<CEventIDManager_Default>*/ void*, EventMapRegistrationType_t) = 0;
+	virtual uint16_t		GetServiceIndex(void) = 0;
+	virtual void		SetServiceIndex(uint16_t index) = 0;
+};
+
+class INetworkServerService : public IEngineService
+{
+public:
+	virtual ~INetworkServerService() {}
+	virtual INetworkGameServer * GetIGameServer(void) = 0;
+	virtual bool	IsActiveInGame(void) const = 0;
+	virtual bool	IsMultiplayer(void) const = 0;
+	virtual void	StartupServer(const GameSessionConfiguration_t& config, ISource2WorldSession* pWorldSession, const char*) = 0;
+	virtual void	SetGameSpawnGroupMgr(IGameSpawnGroupMgr* pMgr) = 0;
+	virtual void	AddServerPrerequisites(const GameSessionConfiguration_t&, const char*, void*, bool) = 0;
+	virtual void	SetServerSocket(int) = 0;
+	virtual bool	IsServerRunning(void) const = 0;
+	virtual void	DisconnectGameNow( /*ENetworkDisconnectionReason*/ int) = 0;
+	virtual void	PrintSpawnGroupStatus(void) const = 0;
+	virtual void	SetFinalSimulationTickThisFrame(int) = 0;
+	virtual void* GetGameServer(void) = 0;
+	virtual int		GetTickInterval(void) const = 0;
+	virtual void	ProcessSocket(void) = 0;
+	virtual int		GetServerNetworkAddress(void) = 0;
+	virtual bool	GameLoadFailed(void) const = 0;
+	virtual void	SetGameLoadFailed(bool bFailed) = 0;
+	virtual void	SetGameLoadStarted(void) = 0;
+	virtual void	StartChangeLevel(void) = 0;
+	virtual void	PreserveSteamID(void) = 0;
+	virtual unsigned long	GetServerSerializersCRC(void) = 0;
+	virtual void* GetServerSerializersMsg(void) = 0;
+};

csgo2/sdk/public/mathlib.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "../sdk.h"
+FORCEINLINE unsigned int SmallestPowerOfTwoGreaterOrEqual(unsigned int x)
+{
+	x -= 1;
+	x |= x >> 1;
+	x |= x >> 2;
+	x |= x >> 4;
+	x |= x >> 8;
+	x |= x >> 16;
+	return x + 1;
+}

csgo2/sdk/public/string_t.h

@@ -0,0 +1,114 @@
+//========= Copyright ?1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Defines the more complete set of operations on the string_t defined
+// 			These should be used instead of direct manipulation to allow more
+//			flexibility in future ports or optimization.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include <cstddef>
+#ifndef STRING_T_H
+#define STRING_T_H
+
+#if defined( _WIN32 )
+#pragma once
+#endif
+
+#ifndef NO_STRING_T
+
+#ifdef WEAK_STRING_T
+
+typedef int	string_t;
+
+//-----------------------------------------------------------------------------
+// Purpose: The correct way to specify the NULL string as a constant.
+//-----------------------------------------------------------------------------
+
+#define NULL_STRING			0
+
+//-----------------------------------------------------------------------------
+// Purpose: Given a string_t, make a C string. By convention the result string 
+// 			pointer should be considered transient and should not be stored.
+//-----------------------------------------------------------------------------
+
+#define STRING( offset )	( ( offset ) ? reinterpret_cast<const char *>( offset ) : "" )
+
+//-----------------------------------------------------------------------------
+// Purpose: Given a C string, obtain a string_t
+//-----------------------------------------------------------------------------
+
+#define MAKE_STRING( str )	( ( *str != 0 ) ? reinterpret_cast<int>( str ) : 0 )
+
+//-----------------------------------------------------------------------------
+
+#define IDENT_STRINGS( s1, s2 )	( *((void **)&(s1)) == *((void **)&(s2)) )
+
+//-----------------------------------------------------------------------------
+
+#else // Strong string_t
+
+//-----------------------------------------------------------------------------
+
+struct string_t
+{
+public:
+	bool operator!() const							{ return ( pszValue == NULL );			}
+	bool operator==( const string_t &rhs ) const	{ return ( pszValue == rhs.pszValue );	}
+	bool operator!=( const string_t &rhs ) const	{ return ( pszValue != rhs.pszValue );	}
+	bool operator<( const string_t &rhs ) const		{ return ((void *)pszValue < (void *)rhs.pszValue ); }
+
+	const char *ToCStr() const						{ return ( pszValue ) ? pszValue : ""; 	}
+	
+protected:
+	const char *pszValue;
+};
+
+//-----------------------------------------------------------------------------
+
+struct castable_string_t : public string_t // string_t is used in unions, hence, no constructor allowed
+{
+	castable_string_t()							{ pszValue = NULL; }
+	castable_string_t( const char *pszFrom )	{ pszValue = (pszFrom && *pszFrom) ? pszFrom : 0; }
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: The correct way to specify the NULL string as a constant.
+//-----------------------------------------------------------------------------
+
+#define NULL_STRING			castable_string_t()
+
+//-----------------------------------------------------------------------------
+// Purpose: Given a string_t, make a C string. By convention the result string 
+// 			pointer should be considered transient and should not be stored.
+//-----------------------------------------------------------------------------
+
+#define STRING( string_t_obj )	(string_t_obj).ToCStr()
+
+//-----------------------------------------------------------------------------
+// Purpose: Given a C string, obtain a string_t
+//-----------------------------------------------------------------------------
+
+#define MAKE_STRING( c_str )	castable_string_t( c_str )
+
+//-----------------------------------------------------------------------------
+
+#define IDENT_STRINGS( s1, s2 )	( *((void **)&(s1)) == *((void **)&(s2)) )
+
+//-----------------------------------------------------------------------------
+
+#endif
+
+#else	// NO_STRING_T
+
+typedef const char *string_t;
+#define NULL_STRING				0
+#define STRING( c_str )			( c_str )
+#define MAKE_STRING( c_str )	( c_str )
+#define IDENT_STRINGS( s1, s2 )	( *((void **)&(s1)) == *((void **)&(s2)) )
+
+#endif	// NO_STRING_T
+
+//=============================================================================
+
+#endif // STRING_T_H

csgo2/sdk/public/utlmap.h

@@ -0,0 +1,200 @@
+//========= Copyright ?1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Header: $
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef UTLMAP_H
+#define UTLMAP_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+#include "../sdk.h"
+//-----------------------------------------------------------------------------
+//
+// Purpose:	An associative container. Pretty much identical to std::map.
+//
+//-----------------------------------------------------------------------------
+
+// This is a useful macro to iterate from start to end in order in a map
+#define FOR_EACH_MAP( mapName, iteratorName ) \
+	for ( int iteratorName = mapName.FirstInorder(); iteratorName != mapName.InvalidIndex(); iteratorName = mapName.NextInorder( iteratorName ) )
+
+// faster iteration, but in an unspecified order
+#define FOR_EACH_MAP_FAST( mapName, iteratorName ) \
+	for ( int iteratorName = 0; iteratorName < mapName.MaxElement(); ++iteratorName ) if ( !mapName.IsValidIndex( iteratorName ) ) continue; else
+
+template <typename K, typename T, typename I = short unsigned int, typename LF = bool (*)(const K&, const K&)>
+class CUtlMap
+{
+public:
+	typedef K KeyType_t;
+	typedef T ElemType_t;
+	typedef I IndexType_t;
+
+	// Less func typedef
+	// Returns true if the first parameter is "less" than the second
+	typedef LF LessFunc_t;
+	
+	// constructor, destructor
+	// Left at growSize = 0, the memory will first allocate 1 element and double in size
+	// at each increment.
+	// LessFunc_t is required, but may be set after the constructor using SetLessFunc() below
+	CUtlMap( int growSize = 0, int initSize = 0, LessFunc_t lessfunc = 0 )
+	 : m_Tree( growSize, initSize, CKeyLess( lessfunc ) )
+	{
+	}
+	
+	CUtlMap( LessFunc_t lessfunc )
+	 : m_Tree( CKeyLess( lessfunc ) )
+	{
+	}
+	
+	void EnsureCapacity( int num )							{ m_Tree.EnsureCapacity( num ); }
+
+	// gets particular elements
+	ElemType_t &		Element( IndexType_t i )			{ return m_Tree.Element( i ).elem; }
+	const ElemType_t &	Element( IndexType_t i ) const		{ return m_Tree.Element( i ).elem; }
+	ElemType_t &		operator[]( IndexType_t i )			{ return m_Tree.Element( i ).elem; }
+	const ElemType_t &	operator[]( IndexType_t i ) const	{ return m_Tree.Element( i ).elem; }
+	KeyType_t &			Key( IndexType_t i )				{ return m_Tree.Element( i ).key; }
+	const KeyType_t &	Key( IndexType_t i ) const			{ return m_Tree.Element( i ).key; }
+
+	
+	// Num elements
+	unsigned int Count() const								{ return m_Tree.Count(); }
+	
+	// Max "size" of the vector
+	IndexType_t  MaxElement() const							{ return m_Tree.MaxElement(); }
+	
+	// Checks if a node is valid and in the map
+	bool  IsValidIndex( IndexType_t i ) const				{ return m_Tree.IsValidIndex( i ); }
+	
+	// Checks if the map as a whole is valid
+	bool  IsValid() const									{ return m_Tree.IsValid(); }
+	
+	// Invalid index
+	static IndexType_t InvalidIndex()						{ return CTree::InvalidIndex(); }
+	
+	// Sets the less func
+	void SetLessFunc( LessFunc_t func )
+	{
+		m_Tree.SetLessFunc( CKeyLess( func ) );
+	}
+	
+	// Insert method (inserts in order)
+	IndexType_t  Insert( const KeyType_t &key, const ElemType_t &insert )
+	{
+		Node_t node;
+		node.key = key;
+		node.elem = insert;
+		return m_Tree.Insert( node );
+	}
+	
+	IndexType_t  Insert( const KeyType_t &key )
+	{
+		Node_t node;
+		node.key = key;
+		return m_Tree.Insert( node );
+	}
+
+	// Find method
+	IndexType_t  Find( const KeyType_t &key ) const
+	{
+		Node_t dummyNode;
+		dummyNode.key = key;
+		return m_Tree.Find( dummyNode );
+	}
+	
+	// Remove methods
+	void     RemoveAt( IndexType_t i )						{ m_Tree.RemoveAt( i ); }
+	bool     Remove( const KeyType_t &key )
+	{
+		Node_t dummyNode;
+		dummyNode.key = key;
+		return m_Tree.Remove( dummyNode );
+	}
+	
+	void     RemoveAll( )									{ m_Tree.RemoveAll(); }
+	void     Purge( )										{ m_Tree.Purge(); }
+			
+	// Iteration
+	IndexType_t  FirstInorder() const						{ return m_Tree.FirstInorder(); }
+	IndexType_t  NextInorder( IndexType_t i ) const			{ return m_Tree.NextInorder( i ); }
+	IndexType_t  PrevInorder( IndexType_t i ) const			{ return m_Tree.PrevInorder( i ); }
+	IndexType_t  LastInorder() const						{ return m_Tree.LastInorder(); }		
+	
+	// If you change the search key, this can be used to reinsert the 
+	// element into the map.
+	void	Reinsert( const KeyType_t &key, IndexType_t i )
+	{
+		m_Tree[i].key = key;
+		m_Tree.Reinsert(i);
+	}
+
+	IndexType_t InsertOrReplace( const KeyType_t &key, const ElemType_t &insert )
+	{
+		IndexType_t i = Find( key );
+		if ( i != InvalidIndex() )
+		{
+			Element( i ) = insert;
+			return i;
+		}
+		
+		return Insert( key, insert );
+	}
+
+	void Swap( CUtlMap< K, T, I > &that )
+	{
+		m_Tree.Swap( that.m_Tree );
+	}
+
+
+	struct Node_t
+	{
+		Node_t()
+		{
+		}
+
+		Node_t( const Node_t &from )
+		  : key( from.key ),
+			elem( from.elem )
+		{
+		}
+
+		KeyType_t	key;
+		ElemType_t	elem;
+	};
+	
+	class CKeyLess
+	{
+	public:
+		CKeyLess( LessFunc_t lessFunc ) : m_LessFunc(lessFunc) {}
+
+		bool operator!() const
+		{
+			return !m_LessFunc;
+		}
+
+		bool operator()( const Node_t &left, const Node_t &right ) const
+		{
+			return m_LessFunc( left.key, right.key );
+		}
+
+		LessFunc_t m_LessFunc;
+	};
+
+	typedef CUtlRBTree<Node_t, I, CKeyLess> CTree;
+
+	CTree *AccessTree()	{ return &m_Tree; }
+
+protected:
+	CTree 	   m_Tree;
+};
+
+//-----------------------------------------------------------------------------
+
+#endif // UTLMAP_H