Initial import of the new Q2PRO tree.

1 files changed, 924 insertions, 0 deletions

diff --git a/source/sv_game.c b/source/sv_game.c
new file mode 100644
index 0000000..50a5b5a
--- /dev/null
+++ b/source/sv_game.c
@@ -0,0 +1,924 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+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; either version 2
+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 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.
+
+*/
+// sv_game.c -- interface to the game dll
+
+#include "sv_local.h"
+#include "mvd_local.h"
+
+//void PF_error (const char *fmt, ...) q_noreturn;
+
+game_export_t	*ge;
+
+
+/*
+===============
+PF_Unicast
+
+Sends the contents of the mutlicast buffer to a single client.
+Archived in MVD stream.
+===============
+*/
+static void PF_Unicast( edict_t *ent, qboolean reliable ) {
+	client_t	*client;
+	int flags, clientNum;
+    svc_ops_t   op;
+
+	if( !ent )
+		return;
+
+	clientNum = NUM_FOR_EDICT( ent ) - 1;
+	if( clientNum < 0 || clientNum >= sv_maxclients->integer ) {
+        Com_WPrintf( "unicast to a non-client %d\n", clientNum );
+        return;
+    }
+
+	client = svs.clientpool + clientNum;
+    if( client->state == cs_free ) {
+        Com_WPrintf( "unicast to a free client %d\n", clientNum );
+        return;
+    }
+
+#if 0
+	// HACK: fixes 'anti-votekick' exploit
+	if( msg_write.data[0] == svc_disconnect ) {
+		SV_RemoveClient( client );
+	}
+#endif
+
+	flags = 0;
+    op = mvd_unicast;
+	if( reliable ) {
+		flags |= MSG_RELIABLE;
+        op = mvd_unicast_r;
+	}
+
+	if( client == svs.mvdummy ) {
+		if( msg_write.data[0] == svc_stufftext && reliable ) {
+            /* probably some Q2Admin crap,
+             * let MVD client process this internally */
+			SV_ClientAddMessage( client, flags );
+		} else if( sv.mvdpaused < PAUSED_FRAMES ) {
+            /* otherwise, MVD client will send
+             * this to everyone in freefloat mode */
+            SV_MvdUnicast( clientNum, op );
+        }
+	} else {
+        SV_ClientAddMessage( client, flags );
+        if( sv_mvd_enable->integer && sv.mvdpaused < PAUSED_FRAMES &&
+            SV_MvdPlayerIsActive( ent ) )
+        {
+            SV_MvdUnicast( clientNum, op );
+        }
+    }
+
+    SZ_Clear( &msg_write );
+}
+
+/*
+=================
+PF_bprintf
+
+Sends text to all active clients.
+Archived in MVD stream.
+=================
+*/
+static void PF_bprintf( int level, const char *fmt, ... ) {
+	va_list		argptr;
+	char		string[MAX_STRING_CHARS];
+	client_t	*client;
+	int			i;
+
+	va_start( argptr, fmt );
+	Q_vsnprintf( string, sizeof( string ), fmt, argptr );
+	va_end( argptr );
+
+	MSG_WriteByte( svc_print );
+	MSG_WriteByte( level );
+	MSG_WriteString( string );
+
+	// echo to console
+	if( dedicated->integer ) {
+		// mask off high bits
+		for( i = 0; string[i]; i++ )
+			string[i] &= 127;
+		Com_Printf( "%s", string );
+	}
+
+    FOR_EACH_CLIENT( client ) {
+		if( client->state != cs_spawned )
+			continue;
+		if( level >= client->messagelevel ) {
+		    SV_ClientAddMessage( client, MSG_RELIABLE );
+        }
+	}
+    if( sv_mvd_enable->integer ) {
+    	SV_MvdMulticast( -1, mvd_multicast_all_r );
+    }
+
+	SZ_Clear( &msg_write );
+}
+
+
+/*
+===============
+PF_dprintf
+
+Debug print to server console.
+===============
+*/
+static void PF_dprintf( const char *fmt, ... ) {
+	char		msg[MAXPRINTMSG];
+	va_list		argptr;
+	
+	va_start( argptr, fmt );
+	Q_vsnprintf( msg, sizeof( msg ), fmt, argptr );
+	va_end( argptr );
+
+	Com_Printf( "%s", msg );
+}
+
+
+/*
+===============
+PF_cprintf
+
+Print to a single client if the level passes.
+Archived in MVD stream.
+===============
+*/
+static void PF_cprintf( edict_t *ent, int level, const char *fmt, ... ) {
+	char		msg[MAX_STRING_CHARS];
+	va_list		argptr;
+	int			clientNum;
+	client_t	*client;
+
+	va_start( argptr, fmt );
+	Q_vsnprintf( msg, sizeof( msg ), fmt, argptr );
+	va_end( argptr );
+
+	if( !ent ) {
+		Com_Printf( "%s", msg );
+		return;
+	}
+
+	clientNum = NUM_FOR_EDICT( ent ) - 1;
+	if( clientNum < 0 || clientNum >= sv_maxclients->integer ) {
+		Com_Error( ERR_DROP, "cprintf to a non-client %d", clientNum );
+    }
+
+	client = svs.clientpool + clientNum;
+    if( client->state == cs_free ) {
+        Com_Error( ERR_DROP, "cprintf to a free client %d", clientNum );
+    }
+
+	MSG_WriteByte( svc_print );
+	MSG_WriteByte( level );
+	MSG_WriteString( msg );
+
+    if( level >= client->messagelevel ) {
+        SV_ClientAddMessage( client, MSG_RELIABLE );
+    }
+
+    if( sv_mvd_enable->integer &&
+        ( client == svs.mvdummy || SV_MvdPlayerIsActive( ent ) ) )
+    {
+        SV_MvdUnicast( clientNum, mvd_unicast_r );
+    }
+
+    SZ_Clear( &msg_write );
+}
+
+
+/*
+===============
+PF_centerprintf
+
+Centerprint to a single client.
+Archived in MVD stream.
+===============
+*/
+static void PF_centerprintf (edict_t *ent, const char *fmt, ...) {
+	char		msg[MAX_STRING_CHARS];
+	va_list		argptr;
+	int			n;
+
+    if( !ent ) {
+        return;
+    }
+	
+	n = NUM_FOR_EDICT(ent);
+	if (n < 1 || n > sv_maxclients->integer) {
+        Com_WPrintf( "centerprintf to a non-client\n" );
+		return;
+    }
+
+	va_start (argptr,fmt);
+	Q_vsnprintf( msg, sizeof( msg ), fmt, argptr );
+	va_end (argptr);
+
+	MSG_WriteByte (svc_centerprint);
+	MSG_WriteString (msg);
+
+	PF_Unicast (ent, qtrue);
+}
+
+
+/*
+===============
+PF_error
+
+Abort the server with a game error
+===============
+*/
+static q_noreturn void PF_error (const char *fmt, ...) {
+	char		msg[MAXPRINTMSG];
+	va_list		argptr;
+	
+	va_start (argptr,fmt);
+	Q_vsnprintf( msg, sizeof( msg ), fmt, argptr );
+	va_end (argptr);
+
+	Com_Error (ERR_DROP, "Game Error: %s", msg);
+}
+
+
+/*
+=================
+PF_setmodel
+
+Also sets mins and maxs for inline bmodels
+=================
+*/
+static void PF_setmodel (edict_t *ent, const char *name) {
+	int		i;
+	cmodel_t	*mod;
+
+	if (!name)
+		Com_Error (ERR_DROP, "PF_setmodel: NULL");
+
+	i = SV_ModelIndex (name);
+		
+	ent->s.modelindex = i;
+
+// if it is an inline model, get the size information for it
+	if( name[0] == '*' ) {
+		mod = CM_InlineModel (&sv.cm, name);
+		VectorCopy (mod->mins, ent->mins);
+		VectorCopy (mod->maxs, ent->maxs);
+		SV_LinkEdict (ent);
+	}
+
+}
+
+/*
+===============
+PF_Configstring
+
+If game is actively running, broadcasts configstring change.
+Archived in MVD stream.
+===============
+*/
+void PF_Configstring( int index, const char *val ) {
+	int length, maxlength;
+	client_t *client;
+
+	if( index < 0 || index >= MAX_CONFIGSTRINGS )
+		Com_Error( ERR_DROP, "PF_Configstring: bad index %i\n", index );
+
+	if( !val )
+		val = "";
+
+	length = strlen( val );
+	maxlength = sizeof( sv.configstrings ) - MAX_QPATH * index;
+	if( length >= maxlength ) {
+		Com_Error( ERR_DROP, "PF_Configstring: index %d overflowed: %d > %d\n",
+            index, length, maxlength - 1 );
+	}
+
+	if( !strcmp( sv.configstrings[index], val ) ) {
+		return;
+	}
+
+	// change the string in sv
+	strcpy( sv.configstrings[index], val );
+	
+	if( sv.state == ss_loading ) {
+		return;
+	}
+
+    if( sv_mvd_enable->integer ) {
+        SV_MvdConfigstring( index, val );
+    }
+
+	// send the update to everyone
+	MSG_WriteByte( svc_configstring );
+	MSG_WriteShort( index );
+	MSG_WriteString( val );
+
+    FOR_EACH_CLIENT( client ) {
+		if( client->state < cs_primed ) {
+			continue;
+		}
+		SV_ClientAddMessage( client, MSG_RELIABLE );
+	}
+
+	SZ_Clear( &msg_write );
+}
+
+static void PF_WriteFloat( float f ) {
+	Com_Error( ERR_DROP, "PF_WriteFloat not implemented" );
+}
+
+
+
+/*
+=================
+PF_inPVS
+
+Also checks portalareas so that doors block sight
+=================
+*/
+static qboolean PF_inPVS (vec3_t p1, vec3_t p2) {
+	cleaf_t	*leaf;
+	int		cluster;
+	int		area1, area2;
+	byte	*mask;
+
+	if( !sv.cm.cache ) {
+		Com_Error( ERR_DROP, "PF_inPVS: no map loaded" );
+	}
+
+	leaf = CM_PointLeaf (&sv.cm, p1);
+	cluster = CM_LeafCluster (leaf);
+	area1 = CM_LeafArea (leaf);
+	mask = CM_ClusterPVS (&sv.cm, cluster);
+
+	leaf = CM_PointLeaf (&sv.cm, p2);
+	cluster = CM_LeafCluster (leaf);
+	area2 = CM_LeafArea (leaf);
+	if ( !Q_IsBitSet( mask, cluster ) )
+		return qfalse;
+	if (!CM_AreasConnected (&sv.cm, area1, area2))
+		return qfalse;		// a door blocks sight
+	return qtrue;
+}
+
+
+/*
+=================
+PF_inPHS
+
+Also checks portalareas so that doors block sound
+=================
+*/
+static qboolean PF_inPHS (vec3_t p1, vec3_t p2) {
+	cleaf_t	*leaf;
+	int		cluster;
+	int		area1, area2;
+	byte	*mask;
+
+	if( !sv.cm.cache ) {
+		Com_Error( ERR_DROP, "PF_inPHS: no map loaded" );
+	}
+
+	leaf = CM_PointLeaf (&sv.cm, p1);
+	cluster = CM_LeafCluster (leaf);
+	area1 = CM_LeafArea (leaf);
+	mask = CM_ClusterPHS (&sv.cm, cluster);
+
+	leaf = CM_PointLeaf (&sv.cm, p2);
+	cluster = CM_LeafCluster (leaf);
+	area2 = CM_LeafArea (leaf);
+	if( !Q_IsBitSet( mask, cluster ) )
+		return qfalse;		// more than one bounce away
+	if (!CM_AreasConnected (&sv.cm, area1, area2))
+		return qfalse;		// a door blocks hearing
+
+	return qtrue;
+}
+
+/*  
+==================
+PF_StartSound
+
+Each entity can have eight independant sound sources, like voice,
+weapon, feet, etc.
+
+If channel & 8, the sound will be sent to everyone, not just
+things in the PHS.
+
+FIXME: if entity isn't in PHS, they must be forced to be sent or
+have the origin explicitly sent.
+
+Channel 0 is an auto-allocate channel, the others override anything
+already running on that entity/channel pair.
+
+An attenuation of 0 will play full volume everywhere in the level.
+Larger attenuations will drop off.  (max 4 attenuation)
+
+Timeofs can range from 0.0 to 0.1 to cause sounds to be started
+later in the frame than they normally would.
+
+If origin is NULL, the origin is determined from the entity origin
+or the midpoint of the entity box for bmodels.
+==================
+*/  
+static void PF_StartSound( edict_t *entity, int channel,
+					    int soundindex, float volume,
+					    float attenuation, float timeofs )
+{       
+	int			sendchan;
+    int			flags;
+	int			ent;
+	vec3_t		origin, clientorg;
+	client_t	*client;
+	byte		*mask;
+	cleaf_t		*leaf;
+	int			area, cluster;
+    player_state_t  *ps;
+
+	if( !entity )
+		return;
+
+	if( volume < 0 || volume > 1.0 )
+		Com_Error( ERR_DROP, "PF_StartSound: volume = %f", volume );
+	if( attenuation < 0 || attenuation > 4 )
+		Com_Error( ERR_DROP, "PF_StartSound: attenuation = %f", attenuation );
+	if( timeofs < 0 || timeofs > 0.255 )
+		Com_Error( ERR_DROP, "PF_StartSound: timeofs = %f", timeofs );
+    if( soundindex < 0 || soundindex >= MAX_SOUNDS )
+		Com_Error( ERR_DROP, "PF_StartSound: soundindex = %d", soundindex );
+
+	ent = NUM_FOR_EDICT( entity );
+
+	sendchan = ( ent << 3 ) | ( channel & 7 );
+
+	// always send the entity number for channel overrides
+	flags = SND_ENT;
+	if( volume != DEFAULT_SOUND_PACKET_VOLUME )
+		flags |= SND_VOLUME;
+	if( attenuation != DEFAULT_SOUND_PACKET_ATTENUATION )
+		flags |= SND_ATTENUATION;
+	if( timeofs )
+		flags |= SND_OFFSET;
+
+    // use the entity origin unless it is a bmodel
+    if( entity->solid == SOLID_BSP ) {
+        VectorAvg( entity->mins, entity->maxs, origin );
+        VectorAdd( entity->s.origin, origin, origin );
+    } else {
+        VectorCopy( entity->s.origin, origin );
+    }
+    
+    // if the sound doesn't attenuate,send it to everyone
+    // (global radio chatter, voiceovers, etc)
+    if( attenuation == ATTN_NONE ) {
+        channel |= CHAN_NO_PHS_ADD;
+    }
+
+    FOR_EACH_CLIENT( client ) {
+		// do not send sounds to connecting clients
+		if( client->state != cs_spawned || client->download || client->nodata ) {
+			continue; 
+		}
+
+        // send origin for invisible entities
+        if( entity->svflags & SVF_NOCLIENT ) {
+            flags |= SND_POS;
+        }
+
+        // default client doesn't know that bmodels have weird origins
+        if( entity->solid == SOLID_BSP && client->protocol == PROTOCOL_VERSION_DEFAULT ) {
+            flags |= SND_POS;
+        }
+
+        if( entity != client->edict ) {
+            // get client viewpos
+            ps = &client->edict->client->ps;
+            VectorMA( ps->viewoffset, 0.125f, ps->pmove.origin, clientorg );
+
+            // PHS cull this sound
+            if( ( channel & CHAN_NO_PHS_ADD ) == 0 ) {
+                leaf = CM_PointLeaf( &sv.cm, clientorg );
+                area = CM_LeafArea( leaf );
+                if( !CM_AreasConnected( &sv.cm, area, entity->areanum ) ) {
+                    // doors can legally straddle two areas, so
+                    // we may need to check another one
+                    if( !entity->areanum2 || !CM_AreasConnected( &sv.cm, area, entity->areanum2 ) ) {
+                        continue;		// blocked by a door
+                    }
+                }
+                cluster = CM_LeafCluster( leaf );
+                mask = CM_ClusterPHS( &sv.cm, cluster );
+                if( !SV_EdictPV( entity, mask ) ) {
+                    continue; // not in PHS
+                }
+            }
+
+            // check if position needs to be explicitly sent
+            if( ( flags & SND_POS ) == 0 ) {
+                mask = CM_FatPVS( &sv.cm, clientorg );
+                if( !SV_EdictPV( entity, mask ) ) {
+                    flags |= SND_POS;   // not in PVS
+                }
+            }
+        }
+
+        MSG_WriteByte( svc_sound );
+        MSG_WriteByte( flags );
+        MSG_WriteByte( soundindex );
+
+        if( flags & SND_VOLUME )
+            MSG_WriteByte( volume * 255 );
+        if( flags & SND_ATTENUATION )
+            MSG_WriteByte( attenuation * 64 );
+        if( flags & SND_OFFSET )
+            MSG_WriteByte( timeofs * 1000 );
+
+        MSG_WriteShort( sendchan );
+
+        if( flags & SND_POS )
+            MSG_WritePos( origin );
+
+        flags &= ~SND_POS;
+
+	    if( channel & CHAN_RELIABLE ) {
+		    SV_ClientAddMessage( client, MSG_RELIABLE|MSG_CLEAR );
+        } else {
+		    SV_ClientAddMessage( client, MSG_CLEAR );
+        }
+    }
+
+    if( svs.mvdummy && sv.mvdpaused < PAUSED_FRAMES ) {
+        int extrabits = 0;
+
+        if( channel & CHAN_NO_PHS_ADD ) {
+            extrabits |= 1;
+        }
+	    if( channel & CHAN_RELIABLE ) {
+            extrabits |= 2;
+        }
+
+        SZ_WriteByte( &sv.multicast, mvd_sound | ( extrabits << SVCMD_BITS ) );
+        SZ_WriteByte( &sv.multicast, flags );
+        SZ_WriteByte( &sv.multicast, soundindex );
+
+        if( flags & SND_VOLUME )
+            SZ_WriteByte( &sv.multicast, volume * 255 );
+        if( flags & SND_ATTENUATION )
+            SZ_WriteByte( &sv.multicast, attenuation * 64 );
+        if( flags & SND_OFFSET )
+            SZ_WriteByte( &sv.multicast, timeofs * 1000 );
+
+        SZ_WriteShort( &sv.multicast, sendchan );
+    }
+}
+
+static void PF_PositionedSound( vec3_t origin, edict_t *entity, int channel,
+					            int soundindex, float volume,
+					            float attenuation, float timeofs )
+{       
+	int			sendchan;
+    int			flags;
+	int			ent;
+
+	if( !origin )
+		Com_Error( ERR_DROP, "PF_PositionedSound: NULL origin" );
+	if( volume < 0 || volume > 1.0 )
+		Com_Error( ERR_DROP, "PF_PositionedSound: volume = %f", volume );
+	if( attenuation < 0 || attenuation > 4 )
+		Com_Error( ERR_DROP, "PF_PositionedSound: attenuation = %f", attenuation );
+	if( timeofs < 0 || timeofs > 0.255 )
+		Com_Error( ERR_DROP, "PF_PositionedSound: timeofs = %f", timeofs );
+    if( soundindex < 0 || soundindex >= MAX_SOUNDS )
+		Com_Error( ERR_DROP, "PF_PositionedSound: soundindex = %d", soundindex );
+
+	ent = NUM_FOR_EDICT( entity );
+
+	sendchan = ( ent << 3 ) | ( channel & 7 );
+
+	// always send the entity number for channel overrides
+	flags = SND_ENT|SND_POS;
+	if( volume != DEFAULT_SOUND_PACKET_VOLUME )
+		flags |= SND_VOLUME;
+	if( attenuation != DEFAULT_SOUND_PACKET_ATTENUATION )
+		flags |= SND_ATTENUATION;
+	if( timeofs )
+		flags |= SND_OFFSET;
+
+    MSG_WriteByte( svc_sound );
+    MSG_WriteByte( flags );
+    MSG_WriteByte( soundindex );
+
+    if( flags & SND_VOLUME )
+        MSG_WriteByte( volume * 255 );
+    if( flags & SND_ATTENUATION )
+        MSG_WriteByte( attenuation * 64 );
+    if( flags & SND_OFFSET )
+        MSG_WriteByte( timeofs * 1000 );
+
+    MSG_WriteShort( sendchan );
+    MSG_WritePos( origin );
+
+	// if the sound doesn't attenuate,send it to everyone
+	// (global radio chatter, voiceovers, etc)
+	if( attenuation == ATTN_NONE || ( channel & CHAN_NO_PHS_ADD ) ) {
+	    if( channel & CHAN_RELIABLE ) {
+            SV_Multicast( NULL, MULTICAST_ALL_R );
+        } else {
+            SV_Multicast( NULL, MULTICAST_ALL );
+        }
+    } else {
+	    if( channel & CHAN_RELIABLE ) {
+            SV_Multicast( origin, MULTICAST_PHS_R );
+        } else {
+            SV_Multicast( origin, MULTICAST_PHS );
+        }
+    }
+}
+
+
+void PF_Pmove( pmove_t *pm ) {
+	if( !sv_client ) {
+		//Pmove( pm ); // TODO
+		return;
+	}
+
+	Pmove( pm, &sv_client->pmp );
+}
+
+static cvar_t *PF_cvar( const char *name, const char *value, int flags ) {
+	cvar_t *var;
+
+	if( flags & CVAR_EXTENDED_MASK ) {
+		Com_WPrintf( "Game DLL attemped to set extended flags on variable '%s', cleared.\n", name );
+		flags &= ~CVAR_EXTENDED_MASK;
+	}
+
+	var = Cvar_Get( name, value, flags );
+	if( !var->subsystem ) {
+		var->subsystem = CVAR_SYSTEM_GAME;
+	}
+
+	return var;
+}
+
+static void PF_AddCommandString( const char *string ) {
+	Cbuf_AddTextEx( &cmd_buffer, string );
+}
+
+static void PF_SetAreaPortalState( int portalnum, qboolean open ) {
+	if( !sv.cm.cache ) {
+		Com_Error( ERR_DROP, "PF_SetAreaPortalState: no map loaded" );
+	}
+	CM_SetAreaPortalState( &sv.cm, portalnum, open );
+}
+
+static qboolean PF_AreasConnected( int area1, int area2 ) {
+	if( !sv.cm.cache ) {
+		Com_Error( ERR_DROP, "PF_AreasConnected: no map loaded" );
+	}
+	return CM_AreasConnected( &sv.cm, area1, area2 );
+}
+
+static void *PF_TagMalloc( int size, memtag_t tag ) {
+    void *ptr;
+
+    if( !size ) {
+        return NULL;
+    }
+
+    ptr = Z_TagMalloc( size, tag );
+    memset( ptr, 0, size );
+
+    return ptr;
+}
+
+//==============================================
+
+static void *game_library;
+
+/*
+===============
+SV_ShutdownGameProgs
+
+Called when either the entire server is being killed, or
+it is changing to a different game directory.
+===============
+*/
+void SV_ShutdownGameProgs (void)
+{
+	if (!ge)
+		return;
+	ge->Shutdown ();
+	ge = NULL;
+    if( game_library ) {
+    	Sys_FreeLibrary( game_library );
+	    game_library = NULL;
+    }
+}
+
+#if 0
+static qboolean SV_GameSetupCallback( api_type_t type, void *api ) {
+	switch( type ) {
+	case API_CMD:
+		Cmd_FillAPI( ( cmdAPI_t * )api );
+		break;
+	case API_CVAR:
+		Cvar_FillAPI( ( cvarAPI_t * )api );
+		break;
+	case API_FS:
+		FS_FillAPI( ( fsAPI_t * )api );
+		break;
+	case API_COMMON:
+		Com_FillAPI( ( commonAPI_t * )api );
+		break;
+	case API_SYSTEM:
+		Sys_FillAPI( ( sysAPI_t * )api );
+		break;
+	default:
+		Com_Error( ERR_FATAL, "SV_GameSetupCallback: bad api type" );
+	}
+
+	return qtrue;
+}
+#endif
+
+/*
+===============
+SV_InitGameProgs
+
+Init the game subsystem for a new map
+===============
+*/
+void SCR_DebugGraph (float value, int color);
+
+void SV_InitGameProgs ( void )
+{
+	game_import_t	import;
+	char	path[MAX_OSPATH];
+    game_export_t	*(*entry)( game_import_t * ) = NULL;
+	/*moduleEntry_t moduleEntry;
+	moduleInfo_t info;
+	moduleCapability_t caps;
+	APISetupCallback_t callback;*/
+
+	// unload anything we have now
+	SV_ShutdownGameProgs ();
+
+#ifdef _WIN32
+	// FIXME: check current debug directory first for
+    // e.g. running legacy stuff like Q2Admin
+	Com_sprintf( path, sizeof( path ), "%s" PATH_SEP_STRING "release"
+        PATH_SEP_STRING GAMELIB, Sys_GetCurrentDirectory() );
+    entry = Sys_LoadLibrary( path, "GetGameAPI", &game_library );
+	if( !entry )
+#endif
+    {
+        // try refdir first for development purposes
+        Com_sprintf( path, sizeof( path ), "%s" PATH_SEP_STRING GAMELIB,
+            sys_refdir->string );
+        entry = Sys_LoadLibrary( path, "GetGameAPI", &game_library );
+        if( !entry ) {
+            // try gamedir
+            if( fs_game->string[0] ) {
+                Com_sprintf( path, sizeof( path ), "%s" PATH_SEP_STRING "%s"
+                    PATH_SEP_STRING GAMELIB, sys_libdir->string, fs_game->string );
+                entry = Sys_LoadLibrary( path, "GetGameAPI", &game_library );
+            }
+
+            if( !entry ) {
+                // try baseq2
+                Com_sprintf( path, sizeof( path ), "%s" PATH_SEP_STRING BASEGAME
+                    PATH_SEP_STRING GAMELIB, sys_libdir->string );
+                entry = Sys_LoadLibrary( path, "GetGameAPI", &game_library );
+                if( !entry ) {
+                    Com_Error( ERR_DROP, "Failed to load game DLL" );
+                }
+            }
+        }
+    }
+
+	// load a new game dll
+	import.multicast = SV_Multicast;
+	import.unicast = PF_Unicast;
+	import.bprintf = PF_bprintf;
+	import.dprintf = PF_dprintf;
+	import.cprintf = PF_cprintf;
+	import.centerprintf = PF_centerprintf;
+	import.error = PF_error;
+
+	import.linkentity = SV_LinkEdict;
+	import.unlinkentity = SV_UnlinkEdict;
+	import.BoxEdicts = SV_AreaEdicts;
+#ifdef _WIN32
+#ifdef __GNUC__
+	import.trace = ( sv_trace_t )SV_Trace_Old;
+#else
+	import.trace = SV_Trace;
+#endif
+#else /* _WIN32 */
+	if( sv_oldgame_hack->integer ) {
+		import.trace = ( sv_trace_t )SV_Trace_Old;
+	} else {
+		import.trace = SV_Trace;
+	}
+#endif /* !_WIN32 */
+	import.pointcontents = SV_PointContents;
+	import.setmodel = PF_setmodel;
+	import.inPVS = PF_inPVS;
+	import.inPHS = PF_inPHS;
+	import.Pmove = PF_Pmove;
+
+	import.modelindex = SV_ModelIndex;
+	import.soundindex = SV_SoundIndex;
+	import.imageindex = SV_ImageIndex;
+
+	import.configstring = PF_Configstring;
+	import.sound = PF_StartSound;
+	import.positioned_sound = PF_PositionedSound;
+
+	import.WriteChar = MSG_WriteChar;
+	import.WriteByte = MSG_WriteByte;
+	import.WriteShort = MSG_WriteShort;
+	import.WriteLong = MSG_WriteLong;
+	import.WriteFloat = PF_WriteFloat;
+	import.WriteString = MSG_WriteString;
+	import.WritePosition = MSG_WritePos;
+	import.WriteDir = MSG_WriteDir;
+	import.WriteAngle = MSG_WriteAngle;
+
+	import.TagMalloc = PF_TagMalloc;
+	import.TagFree = Z_Free;
+	import.FreeTags = Z_FreeTags;
+
+	import.cvar = PF_cvar;
+	import.cvar_set = Cvar_UserSet;
+	import.cvar_forceset = Cvar_Set;
+
+	import.argc = Cmd_Argc;
+	import.argv = Cmd_Argv;
+	import.args = Cmd_Args;
+	import.AddCommandString = PF_AddCommandString;
+
+	import.DebugGraph = SCR_DebugGraph;
+	import.SetAreaPortalState = PF_SetAreaPortalState;
+	import.AreasConnected = PF_AreasConnected;
+
+	ge = entry( &import );
+	if (!ge) {
+		Com_Error (ERR_DROP, "Game DLL returned NULL exports");
+    }
+	if (ge->apiversion != GAME_API_VERSION) {
+		Com_Error (ERR_DROP, "Game DLL is version %d, expected %d",
+            ge->apiversion, GAME_API_VERSION);
+    }
+
+#if 0
+    // get extended API
+    moduleEntry = Sys_GetProcAddress( game_library, "moduleEntry" );
+    if( moduleEntry ) {
+        moduleEntry( MQ_GETINFO, &info );
+        if( info.api_version != MODULES_APIVERSION ) {
+            Com_DPrintf( "Game DLL has incompatible extended "
+                "api_version: %d, should be %d\n",
+                info.api_version, MODULES_APIVERSION );
+        } else {
+            caps = ( moduleCapability_t )moduleEntry( MQ_GETCAPS, NULL );
+            if( !( caps & MCP_GAME ) ) {
+                Com_DPrintf( "Game DLL doesn't have GAME capability\n" );
+            } else {
+                callback = ( APISetupCallback_t )moduleEntry( MQ_SETUPAPI,
+                    ( void * )SV_GameSetupCallback );
+                if( !callback ) {
+                    Com_DPrintf( "Game DLL returned NULL callback\n" );
+                } else {
+                    callback( API_GAME, &game_api );
+                    Com_DPrintf( "Extended game API initialized\n" );
+                }
+            }
+        }
+    }
+#endif
+
+    // initialize
+	ge->Init ();
+}
+