#include "sp_python.h"

#include "sp_main.h"

#include "interface.h"

#include "filesystem.h"

#include "eiface.h"

#include "igameevents.h"

#include "convar.h"

#include "Color.h"

#include "vstdlib/random.h"

#include "engine/IEngineTrace.h"

#include "tier2/tier2.h"

#include "game/server/iplayerinfo.h"

#include "shake.h" // Linux compile fails without this.

#include "game/shared/IEffects.h"

#include "utilities/wrap_macros.h"

#include "engine/IEngineSound.h"

#include "engine/IEngineTrace.h"

#include "public/toolframework/itoolentity.h"

#include "dyncall.h"

#include "networkstringtabledefs.h"

#include "edict.h"

#include "convar.h"

#include "utilities/call_python.h"

#include "vphysics_interface.h"

#include "datacache/imdlcache.h"

#include "ivoiceserver.h"

#include "manager.h"

#include "modules/listeners/listeners_manager.h"

#include "utilities/conversions.h"

#include "modules/entities/entities_entity.h"

#include "modules/core/core.h"

#ifdef _WIN32

#include "Windows.h"

#endif

#include "sp_hooks.h"

#if defined(_WIN32)

# pragma warning( disable : 4005 )

#endif

#include "tier0/memdbgon.h"

IVEngineServer* engine = NULL; // helper functions (messaging clients, loading content, making entities, running commands, etc)

IGameEventManager2* gameeventmanager = NULL; // game events interface

IPlayerInfoManager* playerinfomanager = NULL; // game dll interface to interact with players

IBotManager* botmanager = NULL; // game dll interface to interact with bots

IServerPluginHelpers* helpers = NULL; // special 3rd party plugin helpers from the engine

IUniformRandomStream* randomStr = NULL;

IEngineTrace* enginetrace = NULL;

IEngineSound* enginesound = NULL;

CGlobalVars* gpGlobals = NULL;

IFileSystem* filesystem = NULL;

IServerGameDLL* servergamedll = NULL;

IServerTools* servertools = NULL;

IPhysics* physics = NULL;

IPhysicsCollision* physcollision = NULL;

IPhysicsSurfaceProps* physprops = NULL;

IMDLCache* modelcache = NULL;

IVoiceServer* voiceserver = NULL;

INetworkStringTableContainer* networkstringtable = NULL;

extern ICvar* g_pCVar;

extern void InitCommands();

extern void ClearAllCommands();

extern PLUGIN_RESULT DispatchClientCommand(edict_t *pEntity, const CCommand &command);

CSourcePython g_SourcePythonPlugin;

EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CSourcePython, IServerPluginCallbacks, INTERFACEVERSION_ISERVERPLUGINCALLBACKS, g_SourcePythonPlugin );

struct InterfaceHelper_t

};

InterfaceHelper_t gEngineInterfaces[] = {

{INTERFACEVERSION_VENGINESERVER, (void **)&engine},

{INTERFACEVERSION_GAMEEVENTSMANAGER2, (void **)&gameeventmanager},

{INTERFACEVERSION_ISERVERPLUGINHELPERS, (void **)&helpers},

{INTERFACEVERSION_ENGINETRACE_SERVER, (void **)&enginetrace},

{IENGINESOUND_SERVER_INTERFACE_VERSION, (void **)&enginesound},

{VENGINE_SERVER_RANDOM_INTERFACE_VERSION, (void **)&randomStr},

{FILESYSTEM_INTERFACE_VERSION, (void **)&filesystem},

{INTERFACENAME_NETWORKSTRINGTABLESERVER, (void **)&networkstringtable},

{VPHYSICS_INTERFACE_VERSION, (void **)&physics},

{VPHYSICS_COLLISION_INTERFACE_VERSION, (void **)&physcollision},

{VPHYSICS_SURFACEPROPS_INTERFACE_VERSION, (void **)&physprops},

{MDLCACHE_INTERFACE_VERSION, (void **)&modelcache},

{INTERFACEVERSION_VOICESERVER, (void **)&voiceserver},

{NULL, NULL}

};

InterfaceHelper_t gGameInterfaces[] = {

{INTERFACEVERSION_PLAYERINFOMANAGER, (void **)&playerinfomanager},

{INTERFACEVERSION_PLAYERBOTMANAGER, (void **)&botmanager},

{INTERFACEVERSION_SERVERGAMEDLL, (void **)&servergamedll},

{VSERVERTOOLS_INTERFACE_VERSION, (void **)&servertools},

{NULL, NULL}

};

bool GetInterfaces( InterfaceHelper_t* pInterfaceList, CreateInterfaceFn factory )

}

#if defined(ENGINE_ORANGEBOX) || defined(ENGINE_BMS) || defined(ENGINE_GMOD)

SpewRetval_t SP_SpewOutput( SpewType_t spewType, const tchar *pMsg )

}

#else

class SPLoggingListener: public ILoggingListener

} g_LoggingListener;

#endif

CSourcePython::CSourcePython()

}

CSourcePython::~CSourcePython()

{

}

bool CSourcePython::Load( CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory )

}

void CSourcePython::Unload( void )

}

void CSourcePython::Pause( void )

{

}

void CSourcePython::UnPause( void )

{

}

const char *CSourcePython::GetPluginDescription( void )

{

return "Source.Python, (C) 2012-2018, Source.Python Team.";

}

void CSourcePython::LevelInit( char const *pMapName )

{

CALL_LISTENERS(OnLevelInit, pMapName);

}

void CSourcePython::ServerActivate( edict_t *pEdictList, int edictCount, int clientMax )

}

void CSourcePython::GameFrame( bool simulating )

{

CALL_LISTENERS(OnTick);

}

void CSourcePython::LevelShutdown( void ) // !!!!this can get called multiple times per map change

{

CALL_LISTENERS(OnLevelShutdown);

}

void CSourcePython::ClientActive( edict_t *pEntity )

}

void CSourcePython::ClientDisconnect( edict_t *pEntity )

}

void CSourcePython::ClientPutInServer( edict_t *pEntity, char const *playername )

{

CALL_LISTENERS(OnClientPutInServer, ptr(pEntity), playername);

}

void CSourcePython::SetCommandClient( int index )

{

m_iClientCommandIndex = index;

}

void CSourcePython::ClientSettingsChanged( edict_t *pEdict )

}

PLUGIN_RESULT CSourcePython::ClientConnect( bool *bAllowConnect, edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen )

}

PLUGIN_RESULT CSourcePython::NetworkIDValidated( const char *pszUserName, const char *pszNetworkID )

}

void CSourcePython::OnQueryCvarValueFinished( QueryCvarCookie_t iCookie, edict_t *pPlayerEntity,

}

PLUGIN_RESULT CSourcePython::ClientCommand( edict_t *pEntity, const CCommand &args )

{

return DispatchClientCommand(pEntity, args);

}

#if defined(ENGINE_CSGO) || defined(ENGINE_BLADE) || defined(ENGINE_INSURGENCY)

void CSourcePython::ClientFullyConnect( edict_t *pEntity )

}

#endif

#if defined(ENGINE_CSGO) || defined(ENGINE_BMS) || defined(ENGINE_BLADE) || defined(ENGINE_INSURGENCY)

void CSourcePython::OnEdictAllocated( edict_t *edict )

}

void CSourcePython::OnEdictFreed( const edict_t *edict )

{

CALL_LISTENERS(OnEdictFreed, ptr(edict));

}

#endif

#ifdef ENGINE_BMS

void CSourcePython::OnEntityPreSpawned( CBaseEntity *pEntity )

{

CALL_LISTENERS(OnEntityPreSpawned, ptr((CBaseEntityWrapper*) pEntity));

}

#endif

void CSourcePython::OnEntityCreated( CBaseEntity *pEntity )

}

void CSourcePython::OnEntitySpawned( CBaseEntity *pEntity )

{

CALL_LISTENERS(OnEntitySpawned, ptr((CBaseEntityWrapper*) pEntity));

}

void CSourcePython::OnEntityDeleted( CBaseEntity *pEntity )

{

CALL_LISTENERS(OnEntityDeleted, ptr((CBaseEntityWrapper*) pEntity));

}

void CSourcePython::OnDataLoaded( MDLCacheDataType_t type, MDLHandle_t handle )

}

void CSourcePython::OnDataUnloaded( MDLCacheDataType_t type, MDLHandle_t handle )

}

#if defined(ENGINE_CSGO) || defined(ENGINE_INSURGENCY)

void CSourcePython::OnCombinerPreCache(MDLCacheDataType_t type, MDLHandle_t handle )

}

bool CSourcePython::ShouldSupressLoadWarning(MDLHandle_t handle)

}

#endif

#if defined(ENGINE_CSGO)

bool CSourcePython::BNetworkCryptKeyCheckRequired( uint32 unFromIP, uint16 usFromPort,

}

bool CSourcePython::BNetworkCryptKeyValidate( uint32 unFromIP, uint16 usFromPort, uint32 unAccountIdProvidedByClient,

}

#endif