1 /*
2 ===========================================================================
3 Copyright (C) 2013 - 2015, OpenJK contributors
4
5 This file is part of the OpenJK source code.
6
7 OpenJK is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, see <http://www.gnu.org/licenses/>.
18 ===========================================================================
19 */
20
21 // sv_gameapi.cpp -- interface to the game dll
22 //Anything above this #include will be ignored by the compiler
23
24 #include "server.h"
25 #include "botlib/botlib.h"
26 #include "qcommon/stringed_ingame.h"
27 #include "qcommon/RoffSystem.h"
28 #include "ghoul2/ghoul2_shared.h"
29 #include "qcommon/cm_public.h"
30 #include "icarus/GameInterface.h"
31 #include "qcommon/timing.h"
32 #include "NPCNav/navigator.h"
33
34 botlib_export_t *botlib_export;
35
36 // game interface
37 static gameExport_t *ge; // game export table
38 static vm_t *gvm; // game vm, valid for legacy and new api
39
40 //
41 // game vmMain calls
42 //
43
GVM_InitGame(int levelTime,int randomSeed,int restart)44 void GVM_InitGame( int levelTime, int randomSeed, int restart ) {
45 if ( gvm->isLegacy ) {
46 VM_Call( gvm, GAME_INIT, levelTime, randomSeed, restart );
47 return;
48 }
49 VMSwap v( gvm );
50
51 ge->InitGame( levelTime, randomSeed, restart );
52 }
53
GVM_ShutdownGame(int restart)54 void GVM_ShutdownGame( int restart ) {
55 if ( gvm->isLegacy ) {
56 VM_Call( gvm, GAME_SHUTDOWN, restart );
57 return;
58 }
59 VMSwap v( gvm );
60
61 ge->ShutdownGame( restart );
62 }
63
GVM_ClientConnect(int clientNum,qboolean firstTime,qboolean isBot)64 char *GVM_ClientConnect( int clientNum, qboolean firstTime, qboolean isBot ) {
65 if ( gvm->isLegacy )
66 return (char *)VM_Call( gvm, GAME_CLIENT_CONNECT, clientNum, firstTime, isBot );
67 VMSwap v( gvm );
68
69 return ge->ClientConnect( clientNum, firstTime, isBot );
70 }
71
GVM_ClientBegin(int clientNum)72 void GVM_ClientBegin( int clientNum ) {
73 if ( gvm->isLegacy ) {
74 VM_Call( gvm, GAME_CLIENT_BEGIN, clientNum );
75 return;
76 }
77 VMSwap v( gvm );
78
79 ge->ClientBegin( clientNum, qtrue );
80 }
81
GVM_ClientUserinfoChanged(int clientNum)82 qboolean GVM_ClientUserinfoChanged( int clientNum ) {
83 if ( gvm->isLegacy )
84 return (qboolean)VM_Call( gvm, GAME_CLIENT_USERINFO_CHANGED, clientNum );
85 VMSwap v( gvm );
86
87 return ge->ClientUserinfoChanged( clientNum );
88 }
89
GVM_ClientDisconnect(int clientNum)90 void GVM_ClientDisconnect( int clientNum ) {
91 if ( gvm->isLegacy ) {
92 VM_Call( gvm, GAME_CLIENT_DISCONNECT, clientNum );
93 return;
94 }
95 VMSwap v( gvm );
96
97 ge->ClientDisconnect( clientNum );
98 }
99
GVM_ClientCommand(int clientNum)100 void GVM_ClientCommand( int clientNum ) {
101 if ( gvm->isLegacy ) {
102 VM_Call( gvm, GAME_CLIENT_COMMAND, clientNum );
103 return;
104 }
105 VMSwap v( gvm );
106
107 ge->ClientCommand( clientNum );
108 }
109
GVM_ClientThink(int clientNum,usercmd_t * ucmd)110 void GVM_ClientThink( int clientNum, usercmd_t *ucmd ) {
111 if ( gvm->isLegacy ) {
112 VM_Call( gvm, GAME_CLIENT_THINK, clientNum, reinterpret_cast< intptr_t >( ucmd ) );
113 return;
114 }
115 VMSwap v( gvm );
116
117 ge->ClientThink( clientNum, ucmd );
118 }
119
GVM_RunFrame(int levelTime)120 void GVM_RunFrame( int levelTime ) {
121 if ( gvm->isLegacy ) {
122 VM_Call( gvm, GAME_RUN_FRAME, levelTime );
123 return;
124 }
125 VMSwap v( gvm );
126
127 ge->RunFrame( levelTime );
128 }
129
GVM_ConsoleCommand(void)130 qboolean GVM_ConsoleCommand( void ) {
131 if ( gvm->isLegacy )
132 return (qboolean)VM_Call( gvm, GAME_CONSOLE_COMMAND );
133 VMSwap v( gvm );
134
135 return ge->ConsoleCommand();
136 }
137
GVM_BotAIStartFrame(int time)138 int GVM_BotAIStartFrame( int time ) {
139 if ( gvm->isLegacy )
140 return VM_Call( gvm, BOTAI_START_FRAME, time );
141 VMSwap v( gvm );
142
143 return ge->BotAIStartFrame( time );
144 }
145
GVM_ROFF_NotetrackCallback(int entID,const char * notetrack)146 void GVM_ROFF_NotetrackCallback( int entID, const char *notetrack ) {
147 if ( gvm->isLegacy ) {
148 VM_Call( gvm, GAME_ROFF_NOTETRACK_CALLBACK, entID, reinterpret_cast< intptr_t >( notetrack ) );
149 return;
150 }
151 VMSwap v( gvm );
152
153 ge->ROFF_NotetrackCallback( entID, notetrack );
154 }
155
GVM_SpawnRMGEntity(void)156 void GVM_SpawnRMGEntity( void ) {
157 if ( gvm->isLegacy ) {
158 VM_Call( gvm, GAME_SPAWN_RMG_ENTITY );
159 return;
160 }
161 VMSwap v( gvm );
162
163 ge->SpawnRMGEntity();
164 }
165
GVM_ICARUS_PlaySound(void)166 int GVM_ICARUS_PlaySound( void ) {
167 if ( gvm->isLegacy )
168 return VM_Call( gvm, GAME_ICARUS_PLAYSOUND );
169 VMSwap v( gvm );
170
171 return ge->ICARUS_PlaySound();
172 }
173
GVM_ICARUS_Set(void)174 qboolean GVM_ICARUS_Set( void ) {
175 if ( gvm->isLegacy )
176 return (qboolean)VM_Call( gvm, GAME_ICARUS_SET );
177 VMSwap v( gvm );
178
179 return ge->ICARUS_Set();
180 }
181
GVM_ICARUS_Lerp2Pos(void)182 void GVM_ICARUS_Lerp2Pos( void ) {
183 if ( gvm->isLegacy ) {
184 VM_Call( gvm, GAME_ICARUS_LERP2POS );
185 return;
186 }
187 VMSwap v( gvm );
188
189 ge->ICARUS_Lerp2Pos();
190 }
191
GVM_ICARUS_Lerp2Origin(void)192 void GVM_ICARUS_Lerp2Origin( void ) {
193 if ( gvm->isLegacy ) {
194 VM_Call( gvm, GAME_ICARUS_LERP2ORIGIN );
195 return;
196 }
197 VMSwap v( gvm );
198
199 ge->ICARUS_Lerp2Origin();
200 }
201
GVM_ICARUS_Lerp2Angles(void)202 void GVM_ICARUS_Lerp2Angles( void ) {
203 if ( gvm->isLegacy ) {
204 VM_Call( gvm, GAME_ICARUS_LERP2ANGLES );
205 return;
206 }
207 VMSwap v( gvm );
208
209 ge->ICARUS_Lerp2Angles();
210 }
211
GVM_ICARUS_GetTag(void)212 int GVM_ICARUS_GetTag( void ) {
213 if ( gvm->isLegacy )
214 return VM_Call( gvm, GAME_ICARUS_GETTAG );
215 VMSwap v( gvm );
216
217 return ge->ICARUS_GetTag();
218 }
219
GVM_ICARUS_Lerp2Start(void)220 void GVM_ICARUS_Lerp2Start( void ) {
221 if ( gvm->isLegacy ) {
222 VM_Call( gvm, GAME_ICARUS_LERP2START );
223 return;
224 }
225 VMSwap v( gvm );
226
227 ge->ICARUS_Lerp2Start();
228 }
229
GVM_ICARUS_Lerp2End(void)230 void GVM_ICARUS_Lerp2End( void ) {
231 if ( gvm->isLegacy ) {
232 VM_Call( gvm, GAME_ICARUS_LERP2END );
233 return;
234 }
235 VMSwap v( gvm );
236
237 ge->ICARUS_Lerp2End();
238 }
239
GVM_ICARUS_Use(void)240 void GVM_ICARUS_Use( void ) {
241 if ( gvm->isLegacy ) {
242 VM_Call( gvm, GAME_ICARUS_USE );
243 return;
244 }
245 VMSwap v( gvm );
246
247 ge->ICARUS_Use();
248 }
249
GVM_ICARUS_Kill(void)250 void GVM_ICARUS_Kill( void ) {
251 if ( gvm->isLegacy ) {
252 VM_Call( gvm, GAME_ICARUS_KILL );
253 return;
254 }
255 VMSwap v( gvm );
256
257 ge->ICARUS_Kill();
258 }
259
GVM_ICARUS_Remove(void)260 void GVM_ICARUS_Remove( void ) {
261 if ( gvm->isLegacy ) {
262 VM_Call( gvm, GAME_ICARUS_REMOVE );
263 return;
264 }
265 VMSwap v( gvm );
266
267 ge->ICARUS_Remove();
268 }
269
GVM_ICARUS_Play(void)270 void GVM_ICARUS_Play( void ) {
271 if ( gvm->isLegacy ) {
272 VM_Call( gvm, GAME_ICARUS_PLAY );
273 return;
274 }
275 VMSwap v( gvm );
276
277 ge->ICARUS_Play();
278 }
279
GVM_ICARUS_GetFloat(void)280 int GVM_ICARUS_GetFloat( void ) {
281 if ( gvm->isLegacy )
282 return VM_Call( gvm, GAME_ICARUS_GETFLOAT );
283 VMSwap v( gvm );
284
285 return ge->ICARUS_GetFloat();
286 }
287
GVM_ICARUS_GetVector(void)288 int GVM_ICARUS_GetVector( void ) {
289 if ( gvm->isLegacy )
290 return VM_Call( gvm, GAME_ICARUS_GETVECTOR );
291 VMSwap v( gvm );
292
293 return ge->ICARUS_GetVector();
294 }
295
GVM_ICARUS_GetString(void)296 int GVM_ICARUS_GetString( void ) {
297 if ( gvm->isLegacy )
298 return VM_Call( gvm, GAME_ICARUS_GETSTRING );
299 VMSwap v( gvm );
300
301 return ge->ICARUS_GetString();
302 }
303
GVM_ICARUS_SoundIndex(void)304 void GVM_ICARUS_SoundIndex( void ) {
305 if ( gvm->isLegacy ) {
306 VM_Call( gvm, GAME_ICARUS_SOUNDINDEX );
307 return;
308 }
309 VMSwap v( gvm );
310
311 ge->ICARUS_SoundIndex();
312 }
313
GVM_ICARUS_GetSetIDForString(void)314 int GVM_ICARUS_GetSetIDForString( void ) {
315 if ( gvm->isLegacy )
316 return VM_Call( gvm, GAME_ICARUS_GETSETIDFORSTRING );
317 VMSwap v( gvm );
318
319 return ge->ICARUS_GetSetIDForString();
320 }
321
GVM_NAV_ClearPathToPoint(int entID,vec3_t pmins,vec3_t pmaxs,vec3_t point,int clipmask,int okToHitEnt)322 qboolean GVM_NAV_ClearPathToPoint( int entID, vec3_t pmins, vec3_t pmaxs, vec3_t point, int clipmask, int okToHitEnt ) {
323 if ( gvm->isLegacy )
324 return (qboolean)VM_Call( gvm, GAME_NAV_CLEARPATHTOPOINT, entID, reinterpret_cast< intptr_t >( pmins ), reinterpret_cast< intptr_t >( pmaxs ), reinterpret_cast< intptr_t >( point ), clipmask, okToHitEnt );
325 VMSwap v( gvm );
326
327 return ge->NAV_ClearPathToPoint( entID, pmins, pmaxs, point, clipmask, okToHitEnt );
328 }
329
GVM_NPC_ClearLOS2(int entID,const vec3_t end)330 qboolean GVM_NPC_ClearLOS2( int entID, const vec3_t end ) {
331 if ( gvm->isLegacy )
332 return (qboolean)VM_Call( gvm, GAME_NAV_CLEARLOS, entID, reinterpret_cast< intptr_t >( end ) );
333 VMSwap v( gvm );
334
335 return ge->NPC_ClearLOS2( entID, end );
336 }
337
GVM_NAVNEW_ClearPathBetweenPoints(vec3_t start,vec3_t end,vec3_t mins,vec3_t maxs,int ignore,int clipmask)338 int GVM_NAVNEW_ClearPathBetweenPoints( vec3_t start, vec3_t end, vec3_t mins, vec3_t maxs, int ignore, int clipmask ) {
339 if ( gvm->isLegacy )
340 return VM_Call( gvm, GAME_NAV_CLEARPATHBETWEENPOINTS, reinterpret_cast< intptr_t >( start ), reinterpret_cast< intptr_t >( end ), reinterpret_cast< intptr_t >( mins ), reinterpret_cast< intptr_t >( maxs ), ignore, clipmask );
341 VMSwap v( gvm );
342
343 return ge->NAVNEW_ClearPathBetweenPoints( start, end, mins, maxs, ignore, clipmask );
344 }
345
GVM_NAV_CheckNodeFailedForEnt(int entID,int nodeNum)346 qboolean GVM_NAV_CheckNodeFailedForEnt( int entID, int nodeNum ) {
347 if ( gvm->isLegacy )
348 return (qboolean)VM_Call( gvm, GAME_NAV_CHECKNODEFAILEDFORENT, entID, nodeNum );
349 VMSwap v( gvm );
350
351 return ge->NAV_CheckNodeFailedForEnt( entID, nodeNum );
352 }
353
GVM_NAV_EntIsUnlockedDoor(int entityNum)354 qboolean GVM_NAV_EntIsUnlockedDoor( int entityNum ) {
355 if ( gvm->isLegacy )
356 return (qboolean)VM_Call( gvm, GAME_NAV_ENTISUNLOCKEDDOOR, entityNum );
357 VMSwap v( gvm );
358
359 return ge->NAV_EntIsUnlockedDoor( entityNum );
360 }
361
GVM_NAV_EntIsDoor(int entityNum)362 qboolean GVM_NAV_EntIsDoor( int entityNum ) {
363 if ( gvm->isLegacy )
364 return (qboolean)VM_Call( gvm, GAME_NAV_ENTISDOOR, entityNum );
365 VMSwap v( gvm );
366
367 return ge->NAV_EntIsDoor( entityNum );
368 }
369
GVM_NAV_EntIsBreakable(int entityNum)370 qboolean GVM_NAV_EntIsBreakable( int entityNum ) {
371 if ( gvm->isLegacy )
372 return (qboolean)VM_Call( gvm, GAME_NAV_ENTISBREAKABLE, entityNum );
373 VMSwap v( gvm );
374
375 return ge->NAV_EntIsBreakable( entityNum );
376 }
377
GVM_NAV_EntIsRemovableUsable(int entNum)378 qboolean GVM_NAV_EntIsRemovableUsable( int entNum ) {
379 if ( gvm->isLegacy )
380 return (qboolean)VM_Call( gvm, GAME_NAV_ENTISREMOVABLEUSABLE, entNum );
381 VMSwap v( gvm );
382
383 return ge->NAV_EntIsRemovableUsable( entNum );
384 }
385
GVM_NAV_FindCombatPointWaypoints(void)386 void GVM_NAV_FindCombatPointWaypoints( void ) {
387 if ( gvm->isLegacy ) {
388 VM_Call( gvm, GAME_NAV_FINDCOMBATPOINTWAYPOINTS );
389 return;
390 }
391 VMSwap v( gvm );
392
393 ge->NAV_FindCombatPointWaypoints();
394 }
395
GVM_BG_GetItemIndexByTag(int tag,int type)396 int GVM_BG_GetItemIndexByTag( int tag, int type ) {
397 if ( gvm->isLegacy )
398 return VM_Call( gvm, GAME_GETITEMINDEXBYTAG, tag, type );
399 VMSwap v( gvm );
400
401 return ge->BG_GetItemIndexByTag( tag, type );
402 }
403
404 //
405 // game syscalls
406 // only used by legacy mods!
407 //
408
409 // legacy syscall
410
411 siegePers_t sv_siegePersData = {qfalse, 0, 0};
412
413 extern float g_svCullDist;
414 int CM_ModelContents( clipHandle_t model, int subBSPIndex );
415 int CM_LoadSubBSP( const char *name, qboolean clientload );
416 int CM_FindSubBSP( int modelIndex );
417 char *CM_SubBSPEntityString( int index );
418 qboolean Q3_TaskIDPending( sharedEntity_t *ent, taskID_t taskType );
419 void Q3_TaskIDSet( sharedEntity_t *ent, taskID_t taskType, int taskID );
420 void Q3_TaskIDComplete( sharedEntity_t *ent, taskID_t taskType );
421 void Q3_SetVar( int taskID, int entID, const char *type_name, const char *data );
422 int Q3_VariableDeclared( const char *name );
423 int Q3_GetFloatVariable( const char *name, float *value );
424 int Q3_GetStringVariable( const char *name, const char **value );
425 int Q3_GetVectorVariable( const char *name, vec3_t value );
426 void SV_BotWaypointReception( int wpnum, wpobject_t **wps );
427 void SV_BotCalculatePaths( int rmg );
428
SV_LocateGameData(sharedEntity_t * gEnts,int numGEntities,int sizeofGEntity_t,playerState_t * clients,int sizeofGameClient)429 static void SV_LocateGameData( sharedEntity_t *gEnts, int numGEntities, int sizeofGEntity_t, playerState_t *clients, int sizeofGameClient ) {
430 sv.gentities = gEnts;
431 sv.gentitySize = sizeofGEntity_t;
432 sv.num_entities = numGEntities;
433
434 sv.gameClients = clients;
435 sv.gameClientSize = sizeofGameClient;
436 }
437
SV_GameDropClient(int clientNum,const char * reason)438 static void SV_GameDropClient( int clientNum, const char *reason ) {
439 if ( clientNum < 0 || clientNum >= sv_maxclients->integer ) {
440 return;
441 }
442 SV_DropClient( svs.clients + clientNum, reason );
443 }
444
SV_GameSendServerCommand(int clientNum,const char * text)445 static void SV_GameSendServerCommand( int clientNum, const char *text ) {
446 if ( clientNum == -1 ) {
447 SV_SendServerCommand( NULL, "%s", text );
448 } else {
449 if ( clientNum < 0 || clientNum >= sv_maxclients->integer ) {
450 return;
451 }
452 SV_SendServerCommand( svs.clients + clientNum, "%s", text );
453 }
454 }
455
SV_EntityContact(const vec3_t mins,const vec3_t maxs,const sharedEntity_t * gEnt,int capsule)456 static qboolean SV_EntityContact( const vec3_t mins, const vec3_t maxs, const sharedEntity_t *gEnt, int capsule ) {
457 const float *origin, *angles;
458 clipHandle_t ch;
459 trace_t trace;
460
461 // check for exact collision
462 origin = gEnt->r.currentOrigin;
463 angles = gEnt->r.currentAngles;
464
465 ch = SV_ClipHandleForEntity( gEnt );
466 CM_TransformedBoxTrace ( &trace, vec3_origin, vec3_origin, mins, maxs,
467 ch, -1, origin, angles, capsule );
468
469 return (qboolean)trace.startsolid;
470 }
471
SV_SetBrushModel(sharedEntity_t * ent,const char * name)472 static void SV_SetBrushModel( sharedEntity_t *ent, const char *name ) {
473 clipHandle_t h;
474 vec3_t mins, maxs;
475
476 if (!name)
477 {
478 Com_Error( ERR_DROP, "SV_SetBrushModel: NULL" );
479 }
480
481 if (name[0] == '*')
482 {
483 ent->s.modelindex = atoi( name + 1 );
484
485 if (sv.mLocalSubBSPIndex != -1)
486 {
487 ent->s.modelindex += sv.mLocalSubBSPModelOffset;
488 }
489
490 h = CM_InlineModel( ent->s.modelindex );
491
492 CM_ModelBounds(h, mins, maxs);
493
494 VectorCopy (mins, ent->r.mins);
495 VectorCopy (maxs, ent->r.maxs);
496 ent->r.bmodel = qtrue;
497 ent->r.contents = CM_ModelContents( h, -1 );
498 }
499 else if (name[0] == '#')
500 {
501 ent->s.modelindex = CM_LoadSubBSP(va("maps/%s.bsp", name + 1), qfalse);
502 CM_ModelBounds( ent->s.modelindex, mins, maxs );
503
504 VectorCopy (mins, ent->r.mins);
505 VectorCopy (maxs, ent->r.maxs);
506 ent->r.bmodel = qtrue;
507
508 //rwwNOTE: We don't ever want to set contents -1, it includes CONTENTS_LIGHTSABER.
509 //Lots of stuff will explode if there's a brush with CONTENTS_LIGHTSABER that isn't attached to a client owner.
510 //ent->contents = -1; // we don't know exactly what is in the brushes
511 h = CM_InlineModel( ent->s.modelindex );
512 ent->r.contents = CM_ModelContents( h, CM_FindSubBSP(ent->s.modelindex) );
513 }
514 else
515 {
516 Com_Error( ERR_DROP, "SV_SetBrushModel: %s isn't a brush model", name );
517 }
518 }
519
SV_inPVSIgnorePortals(const vec3_t p1,const vec3_t p2)520 static qboolean SV_inPVSIgnorePortals( const vec3_t p1, const vec3_t p2 ) {
521 int leafnum, cluster;
522 // int area1, area2;
523 byte *mask;
524
525 leafnum = CM_PointLeafnum( p1 );
526 cluster = CM_LeafCluster( leafnum );
527 // area1 = CM_LeafArea( leafnum );
528 mask = CM_ClusterPVS( cluster );
529
530 leafnum = CM_PointLeafnum( p2 );
531 cluster = CM_LeafCluster( leafnum );
532 // area2 = CM_LeafArea( leafnum );
533
534 if ( mask && (!(mask[cluster>>3] & (1<<(cluster&7)) ) ) )
535 return qfalse;
536
537 return qtrue;
538 }
539
SV_GetServerinfo(char * buffer,int bufferSize)540 static void SV_GetServerinfo( char *buffer, int bufferSize ) {
541 if ( bufferSize < 1 ) {
542 Com_Error( ERR_DROP, "SV_GetServerinfo: bufferSize == %i", bufferSize );
543 return;
544 }
545 Q_strncpyz( buffer, Cvar_InfoString( CVAR_SERVERINFO ), bufferSize );
546 }
547
SV_AdjustAreaPortalState(sharedEntity_t * ent,qboolean open)548 static void SV_AdjustAreaPortalState( sharedEntity_t *ent, qboolean open ) {
549 svEntity_t *svEnt;
550
551 svEnt = SV_SvEntityForGentity( ent );
552 if ( svEnt->areanum2 == -1 )
553 return;
554
555 CM_AdjustAreaPortalState( svEnt->areanum, svEnt->areanum2, open );
556 }
557
SV_GetUsercmd(int clientNum,usercmd_t * cmd)558 static void SV_GetUsercmd( int clientNum, usercmd_t *cmd ) {
559 if ( clientNum < 0 || clientNum >= sv_maxclients->integer ) {
560 Com_Error( ERR_DROP, "SV_GetUsercmd: bad clientNum:%i", clientNum );
561 return;
562 }
563 *cmd = svs.clients[clientNum].lastUsercmd;
564 }
565
566 static sharedEntity_t gLocalModifier;
ConvertedEntity(sharedEntity_t * ent)567 static sharedEntity_t *ConvertedEntity( sharedEntity_t *ent ) { //Return an entity with the memory shifted around to allow reading/modifying VM memory
568 int i = 0;
569
570 assert(ent);
571
572 gLocalModifier.s = ent->s;
573 gLocalModifier.r = ent->r;
574 while (i < NUM_TIDS)
575 {
576 gLocalModifier.taskID[i] = ent->taskID[i];
577 i++;
578 }
579 i = 0;
580 gLocalModifier.parms = (parms_t *)VM_ArgPtr((intptr_t)ent->parms);
581 while (i < NUM_BSETS)
582 {
583 gLocalModifier.behaviorSet[i] = (char *)VM_ArgPtr((intptr_t)ent->behaviorSet[i]);
584 i++;
585 }
586 i = 0;
587 gLocalModifier.script_targetname = (char *)VM_ArgPtr((intptr_t)ent->script_targetname);
588 gLocalModifier.delayScriptTime = ent->delayScriptTime;
589 gLocalModifier.fullName = (char *)VM_ArgPtr((intptr_t)ent->fullName);
590 gLocalModifier.targetname = (char *)VM_ArgPtr((intptr_t)ent->targetname);
591 gLocalModifier.classname = (char *)VM_ArgPtr((intptr_t)ent->classname);
592
593 gLocalModifier.ghoul2 = ent->ghoul2;
594
595 return &gLocalModifier;
596 }
597
SV_SetActiveSubBSP(int index)598 static const char *SV_SetActiveSubBSP( int index ) {
599 if ( index >= 0 ) {
600 sv.mLocalSubBSPIndex = CM_FindSubBSP( index );
601 sv.mLocalSubBSPModelOffset = index;
602 sv.mLocalSubBSPEntityParsePoint = CM_SubBSPEntityString( sv.mLocalSubBSPIndex );
603 return sv.mLocalSubBSPEntityParsePoint;
604 }
605
606 sv.mLocalSubBSPIndex = -1;
607 return NULL;
608 }
609
SV_GetEntityToken(char * buffer,int bufferSize)610 static qboolean SV_GetEntityToken( char *buffer, int bufferSize ) {
611 char *s;
612
613 if ( sv.mLocalSubBSPIndex == -1 ) {
614 s = COM_Parse( (const char **)&sv.entityParsePoint );
615 Q_strncpyz( buffer, s, bufferSize );
616 if ( !sv.entityParsePoint && !s[0] )
617 return qfalse;
618 else
619 return qtrue;
620 }
621 else {
622 s = COM_Parse( (const char **)&sv.mLocalSubBSPEntityParsePoint);
623 Q_strncpyz( buffer, s, bufferSize );
624 if ( !sv.mLocalSubBSPEntityParsePoint && !s[0] )
625 return qfalse;
626 else
627 return qtrue;
628 }
629 }
630
SV_PrecisionTimerStart(void ** timer)631 static void SV_PrecisionTimerStart( void **timer ) {
632 timing_c *newTimer = new timing_c; //create the new timer
633 *timer = newTimer; //assign the pointer within the pointer to point at the mem addr of our new timer
634 newTimer->Start(); //start the timer
635 }
636
SV_PrecisionTimerEnd(void * timer)637 static int SV_PrecisionTimerEnd( void *timer ) {
638 int r;
639 timing_c *theTimer = (timing_c *)timer; //this is the pointer we assigned in start, so we can directly cast it back
640 r = theTimer->End(); //get the result
641 delete theTimer; //delete the timer since we're done with it
642 return r; //return the result
643 }
644
SV_RegisterSharedMemory(char * memory)645 static void SV_RegisterSharedMemory( char *memory ) {
646 sv.mSharedMemory = memory;
647 }
648
SV_SetServerCull(float cullDistance)649 static void SV_SetServerCull( float cullDistance ) {
650 g_svCullDist = cullDistance;
651 }
652
SV_SiegePersSet(siegePers_t * siegePers)653 static void SV_SiegePersSet( siegePers_t *siegePers ) {
654 sv_siegePersData = *siegePers;
655 }
656
SV_SiegePersGet(siegePers_t * siegePers)657 static void SV_SiegePersGet( siegePers_t *siegePers ) {
658 *siegePers = sv_siegePersData;
659 }
660
SV_ROFF_Clean(void)661 qboolean SV_ROFF_Clean( void ) {
662 return theROFFSystem.Clean( qfalse );
663 }
664
SV_ROFF_UpdateEntities(void)665 void SV_ROFF_UpdateEntities( void ) {
666 theROFFSystem.UpdateEntities( qfalse );
667 }
668
SV_ROFF_Cache(char * file)669 int SV_ROFF_Cache( char *file ) {
670 return theROFFSystem.Cache( file, qfalse );
671 }
672
SV_ROFF_Play(int entID,int roffID,qboolean doTranslation)673 qboolean SV_ROFF_Play( int entID, int roffID, qboolean doTranslation ) {
674 return theROFFSystem.Play( entID, roffID, doTranslation, qfalse );
675 }
676
SV_ROFF_Purge_Ent(int entID)677 qboolean SV_ROFF_Purge_Ent( int entID ) {
678 return theROFFSystem.PurgeEnt( entID, qfalse );
679 }
680
SV_ICARUS_RegisterScript(const char * name,qboolean bCalledDuringInterrogate)681 static qboolean SV_ICARUS_RegisterScript( const char *name, qboolean bCalledDuringInterrogate ) {
682 return (qboolean)ICARUS_RegisterScript( name, bCalledDuringInterrogate );
683 }
684
SV_ICARUS_ValidEnt(sharedEntity_t * ent)685 static qboolean SV_ICARUS_ValidEnt( sharedEntity_t *ent ) {
686 return (qboolean)ICARUS_ValidEnt( ent );
687 }
688
ICARUS_IsInitialized(int entID)689 static qboolean ICARUS_IsInitialized( int entID ) {
690 if ( !gSequencers[entID] || !gTaskManagers[entID] )
691 return qfalse;
692
693 return qtrue;
694 }
695
ICARUS_MaintainTaskManager(int entID)696 static qboolean ICARUS_MaintainTaskManager( int entID ) {
697 if ( gTaskManagers[entID] ) {
698 gTaskManagers[entID]->Update();
699 return qtrue;
700 }
701 return qfalse;
702 }
703
ICARUS_IsRunning(int entID)704 static qboolean ICARUS_IsRunning( int entID ) {
705 if ( !gTaskManagers[entID] || !gTaskManagers[entID]->IsRunning() )
706 return qfalse;
707 return qtrue;
708 }
709
ICARUS_TaskIDPending(sharedEntity_t * ent,int taskID)710 static qboolean ICARUS_TaskIDPending( sharedEntity_t *ent, int taskID ) {
711 return Q3_TaskIDPending( ent, (taskID_t)taskID );
712 }
713
SV_ICARUS_TaskIDSet(sharedEntity_t * ent,int taskType,int taskID)714 static void SV_ICARUS_TaskIDSet( sharedEntity_t *ent, int taskType, int taskID ) {
715 Q3_TaskIDSet( ent, (taskID_t)taskType, taskID );
716 }
717
SV_ICARUS_TaskIDComplete(sharedEntity_t * ent,int taskType)718 static void SV_ICARUS_TaskIDComplete( sharedEntity_t *ent, int taskType ) {
719 Q3_TaskIDComplete( ent, (taskID_t)taskType );
720 }
721
SV_ICARUS_GetStringVariable(const char * name,const char * value)722 static int SV_ICARUS_GetStringVariable( const char *name, const char *value ) {
723 const char *rec = (const char *)value;
724 return Q3_GetStringVariable( name, (const char **)&rec );
725 }
SV_ICARUS_GetVectorVariable(const char * name,const vec3_t value)726 static int SV_ICARUS_GetVectorVariable( const char *name, const vec3_t value ) {
727 return Q3_GetVectorVariable( name, (float *)value );
728 }
729
SV_Nav_Init(void)730 static void SV_Nav_Init( void ) {
731 navigator.Init();
732 }
733
SV_Nav_Free(void)734 static void SV_Nav_Free( void ) {
735 navigator.Free();
736 }
737
SV_Nav_Load(const char * filename,int checksum)738 static qboolean SV_Nav_Load( const char *filename, int checksum ) {
739 return (qboolean)navigator.Load( filename, checksum );
740 }
741
SV_Nav_Save(const char * filename,int checksum)742 static qboolean SV_Nav_Save( const char *filename, int checksum ) {
743 return (qboolean)navigator.Save( filename, checksum );
744 }
745
SV_Nav_AddRawPoint(vec3_t point,int flags,int radius)746 static int SV_Nav_AddRawPoint( vec3_t point, int flags, int radius ) {
747 return navigator.AddRawPoint( point, flags, radius );
748 }
749
SV_Nav_CalculatePaths(qboolean recalc)750 static void SV_Nav_CalculatePaths( qboolean recalc ) {
751 navigator.CalculatePaths( recalc );
752 }
753
SV_Nav_HardConnect(int first,int second)754 static void SV_Nav_HardConnect( int first, int second ) {
755 navigator.HardConnect( first, second );
756 }
757
SV_Nav_ShowNodes(void)758 static void SV_Nav_ShowNodes( void ) {
759 navigator.ShowNodes();
760 }
761
SV_Nav_ShowEdges(void)762 static void SV_Nav_ShowEdges( void ) {
763 navigator.ShowEdges();
764 }
765
SV_Nav_ShowPath(int start,int end)766 static void SV_Nav_ShowPath( int start, int end ) {
767 navigator.ShowPath( start, end );
768 }
769
SV_Nav_GetNearestNode(sharedEntity_t * ent,int lastID,int flags,int targetID)770 static int SV_Nav_GetNearestNode( sharedEntity_t *ent, int lastID, int flags, int targetID ) {
771 return navigator.GetNearestNode( ent, lastID, flags, targetID );
772 }
773
SV_Nav_GetBestNode(int startID,int endID,int rejectID)774 static int SV_Nav_GetBestNode( int startID, int endID, int rejectID ) {
775 return navigator.GetBestNode( startID, endID, rejectID );
776 }
777
SV_Nav_GetNodePosition(int nodeID,vec3_t out)778 static int SV_Nav_GetNodePosition( int nodeID, vec3_t out ) {
779 return navigator.GetNodePosition( nodeID, out );
780 }
781
SV_Nav_GetNodeNumEdges(int nodeID)782 static int SV_Nav_GetNodeNumEdges( int nodeID ) {
783 return navigator.GetNodeNumEdges( nodeID );
784 }
785
SV_Nav_GetNodeEdge(int nodeID,int edge)786 static int SV_Nav_GetNodeEdge( int nodeID, int edge ) {
787 return navigator.GetNodeEdge( nodeID, edge );
788 }
789
SV_Nav_GetNumNodes(void)790 static int SV_Nav_GetNumNodes( void ) {
791 return navigator.GetNumNodes();
792 }
793
SV_Nav_Connected(int startID,int endID)794 static qboolean SV_Nav_Connected( int startID, int endID ) {
795 return (qboolean)navigator.Connected( startID, endID );
796 }
797
SV_Nav_GetPathCost(int startID,int endID)798 static int SV_Nav_GetPathCost( int startID, int endID ) {
799 return navigator.GetPathCost( startID, endID );
800 }
801
SV_Nav_GetEdgeCost(int startID,int endID)802 static int SV_Nav_GetEdgeCost( int startID, int endID ) {
803 return navigator.GetEdgeCost( startID, endID );
804 }
805
SV_Nav_GetProjectedNode(vec3_t origin,int nodeID)806 static int SV_Nav_GetProjectedNode( vec3_t origin, int nodeID ) {
807 return navigator.GetProjectedNode( origin, nodeID );
808 }
809
SV_Nav_CheckFailedNodes(sharedEntity_t * ent)810 static void SV_Nav_CheckFailedNodes( sharedEntity_t *ent ) {
811 navigator.CheckFailedNodes( ent );
812 }
813
SV_Nav_AddFailedNode(sharedEntity_t * ent,int nodeID)814 static void SV_Nav_AddFailedNode( sharedEntity_t *ent, int nodeID ) {
815 navigator.AddFailedNode( ent, nodeID );
816 }
817
SV_Nav_NodeFailed(sharedEntity_t * ent,int nodeID)818 static qboolean SV_Nav_NodeFailed( sharedEntity_t *ent, int nodeID ) {
819 return navigator.NodeFailed( ent, nodeID );
820 }
821
SV_Nav_NodesAreNeighbors(int startID,int endID)822 static qboolean SV_Nav_NodesAreNeighbors( int startID, int endID ) {
823 return navigator.NodesAreNeighbors( startID, endID );
824 }
825
SV_Nav_ClearFailedEdge(failedEdge_t * failedEdge)826 static void SV_Nav_ClearFailedEdge( failedEdge_t *failedEdge ) {
827 navigator.ClearFailedEdge( failedEdge );
828 }
829
SV_Nav_ClearAllFailedEdges(void)830 static void SV_Nav_ClearAllFailedEdges( void ) {
831 navigator.ClearAllFailedEdges();
832 }
833
SV_Nav_EdgeFailed(int startID,int endID)834 static int SV_Nav_EdgeFailed( int startID, int endID ) {
835 return navigator.EdgeFailed( startID, endID );
836 }
837
SV_Nav_AddFailedEdge(int entID,int startID,int endID)838 static void SV_Nav_AddFailedEdge( int entID, int startID, int endID ) {
839 navigator.AddFailedEdge( entID, startID, endID );
840 }
841
SV_Nav_CheckFailedEdge(failedEdge_t * failedEdge)842 static qboolean SV_Nav_CheckFailedEdge( failedEdge_t *failedEdge ) {
843 return navigator.CheckFailedEdge( failedEdge );
844 }
845
SV_Nav_CheckAllFailedEdges(void)846 static void SV_Nav_CheckAllFailedEdges( void ) {
847 navigator.CheckAllFailedEdges();
848 }
849
SV_Nav_RouteBlocked(int startID,int testEdgeID,int endID,int rejectRank)850 static qboolean SV_Nav_RouteBlocked( int startID, int testEdgeID, int endID, int rejectRank ) {
851 return navigator.RouteBlocked( startID, testEdgeID, endID, rejectRank );
852 }
853
SV_Nav_GetBestNodeAltRoute(int startID,int endID,int * pathCost,int rejectID)854 static int SV_Nav_GetBestNodeAltRoute( int startID, int endID, int *pathCost, int rejectID ) {
855 return navigator.GetBestNodeAltRoute( startID, endID, pathCost, rejectID );
856 }
857
SV_Nav_GetBestNodeAltRoute2(int startID,int endID,int rejectID)858 static int SV_Nav_GetBestNodeAltRoute2( int startID, int endID, int rejectID ) {
859 return navigator.GetBestNodeAltRoute( startID, endID, rejectID );
860 }
861
SV_Nav_GetBestPathBetweenEnts(sharedEntity_t * ent,sharedEntity_t * goal,int flags)862 static int SV_Nav_GetBestPathBetweenEnts( sharedEntity_t *ent, sharedEntity_t *goal, int flags ) {
863 return navigator.GetBestPathBetweenEnts( ent, goal, flags );
864 }
865
SV_Nav_GetNodeRadius(int nodeID)866 static int SV_Nav_GetNodeRadius( int nodeID ) {
867 return navigator.GetNodeRadius( nodeID );
868 }
869
SV_Nav_CheckBlockedEdges(void)870 static void SV_Nav_CheckBlockedEdges( void ) {
871 navigator.CheckBlockedEdges();
872 }
873
SV_Nav_ClearCheckedNodes(void)874 static void SV_Nav_ClearCheckedNodes( void ) {
875 navigator.ClearCheckedNodes();
876 }
877
SV_Nav_CheckedNode(int wayPoint,int ent)878 static int SV_Nav_CheckedNode( int wayPoint, int ent ) {
879 return navigator.CheckedNode( wayPoint, ent );
880 }
881
SV_Nav_SetCheckedNode(int wayPoint,int ent,int value)882 static void SV_Nav_SetCheckedNode( int wayPoint, int ent, int value ) {
883 navigator.SetCheckedNode( wayPoint, ent, value );
884 }
885
SV_Nav_FlagAllNodes(int newFlag)886 static void SV_Nav_FlagAllNodes( int newFlag ) {
887 navigator.FlagAllNodes( newFlag );
888 }
889
SV_Nav_GetPathsCalculated(void)890 static qboolean SV_Nav_GetPathsCalculated( void ) {
891 return navigator.pathsCalculated;
892 }
893
SV_Nav_SetPathsCalculated(qboolean newVal)894 static void SV_Nav_SetPathsCalculated( qboolean newVal ) {
895 navigator.pathsCalculated = newVal;
896 }
897
SV_BotLoadCharacter(char * charfile,float skill)898 static int SV_BotLoadCharacter( char *charfile, float skill ) {
899 return botlib_export->ai.BotLoadCharacter( charfile, skill );
900 }
901
SV_BotFreeCharacter(int character)902 static void SV_BotFreeCharacter( int character ) {
903 botlib_export->ai.BotFreeCharacter( character );
904 }
905
SV_Characteristic_Float(int character,int index)906 static float SV_Characteristic_Float( int character, int index ) {
907 return botlib_export->ai.Characteristic_Float( character, index );
908 }
909
SV_Characteristic_BFloat(int character,int index,float min,float max)910 static float SV_Characteristic_BFloat( int character, int index, float min, float max ) {
911 return botlib_export->ai.Characteristic_BFloat( character, index, min, max );
912 }
913
SV_Characteristic_Integer(int character,int index)914 static int SV_Characteristic_Integer( int character, int index ) {
915 return botlib_export->ai.Characteristic_Integer( character, index );
916 }
917
SV_Characteristic_BInteger(int character,int index,int min,int max)918 static int SV_Characteristic_BInteger( int character, int index, int min, int max ) {
919 return botlib_export->ai.Characteristic_BInteger( character, index, min, max );
920 }
921
SV_Characteristic_String(int character,int index,char * buf,int size)922 static void SV_Characteristic_String( int character, int index, char *buf, int size ) {
923 botlib_export->ai.Characteristic_String( character, index, buf, size );
924 }
925
SV_BotAllocChatState(void)926 static int SV_BotAllocChatState( void ) {
927 return botlib_export->ai.BotAllocChatState();
928 }
929
SV_BotFreeChatState(int handle)930 static void SV_BotFreeChatState( int handle ) {
931 botlib_export->ai.BotFreeChatState( handle );
932 }
933
SV_BotQueueConsoleMessage(int chatstate,int type,char * message)934 static void SV_BotQueueConsoleMessage( int chatstate, int type, char *message ) {
935 botlib_export->ai.BotQueueConsoleMessage( chatstate, type, message );
936 }
937
SV_BotRemoveConsoleMessage(int chatstate,int handle)938 static void SV_BotRemoveConsoleMessage( int chatstate, int handle ) {
939 botlib_export->ai.BotRemoveConsoleMessage( chatstate, handle );
940 }
941
SV_BotNextConsoleMessage(int chatstate,void * cm)942 static int SV_BotNextConsoleMessage( int chatstate, void *cm ) {
943 return botlib_export->ai.BotNextConsoleMessage( chatstate, (bot_consolemessage_s *)cm );
944 }
945
SV_BotNumConsoleMessages(int chatstate)946 static int SV_BotNumConsoleMessages( int chatstate ) {
947 return botlib_export->ai.BotNumConsoleMessages( chatstate );
948 }
949
SV_BotInitialChat(int chatstate,char * type,int mcontext,char * var0,char * var1,char * var2,char * var3,char * var4,char * var5,char * var6,char * var7)950 static void SV_BotInitialChat( int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 ) {
951 botlib_export->ai.BotInitialChat( chatstate, type, mcontext, var0, var1, var2, var3, var4, var5, var6, var7 );
952 }
953
SV_BotReplyChat(int chatstate,char * message,int mcontext,int vcontext,char * var0,char * var1,char * var2,char * var3,char * var4,char * var5,char * var6,char * var7)954 static int SV_BotReplyChat( int chatstate, char *message, int mcontext, int vcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 ) {
955 return botlib_export->ai.BotReplyChat( chatstate, message, mcontext, vcontext, var0, var1, var2, var3, var4, var5, var6, var7 );
956 }
957
SV_BotChatLength(int chatstate)958 static int SV_BotChatLength( int chatstate ) {
959 return botlib_export->ai.BotChatLength( chatstate );
960 }
961
SV_BotEnterChat(int chatstate,int client,int sendto)962 static void SV_BotEnterChat( int chatstate, int client, int sendto ) {
963 botlib_export->ai.BotEnterChat( chatstate, client, sendto );
964 }
965
SV_StringContains(char * str1,char * str2,int casesensitive)966 static int SV_StringContains( char *str1, char *str2, int casesensitive ) {
967 return botlib_export->ai.StringContains( str1, str2, casesensitive );
968 }
969
SV_BotFindMatch(char * str,void * match,unsigned long int context)970 static int SV_BotFindMatch( char *str, void *match, unsigned long int context ) {
971 return botlib_export->ai.BotFindMatch( str, (bot_match_s *)match, context );
972 }
973
SV_BotMatchVariable(void * match,int variable,char * buf,int size)974 static void SV_BotMatchVariable( void *match, int variable, char *buf, int size ) {
975 botlib_export->ai.BotMatchVariable( (bot_match_s *)match, variable, buf, size );
976 }
977
SV_UnifyWhiteSpaces(char * string)978 static void SV_UnifyWhiteSpaces( char *string ) {
979 botlib_export->ai.UnifyWhiteSpaces( string );
980 }
981
SV_BotReplaceSynonyms(char * string,unsigned long int context)982 static void SV_BotReplaceSynonyms( char *string, unsigned long int context ) {
983 botlib_export->ai.BotReplaceSynonyms( string, context );
984 }
985
SV_BotLoadChatFile(int chatstate,char * chatfile,char * chatname)986 static int SV_BotLoadChatFile( int chatstate, char *chatfile, char *chatname ) {
987 return botlib_export->ai.BotLoadChatFile( chatstate, chatfile, chatname );
988 }
989
SV_BotSetChatGender(int chatstate,int gender)990 static void SV_BotSetChatGender( int chatstate, int gender ) {
991 botlib_export->ai.BotSetChatGender( chatstate, gender );
992 }
993
SV_BotSetChatName(int chatstate,char * name,int client)994 static void SV_BotSetChatName( int chatstate, char *name, int client ) {
995 botlib_export->ai.BotSetChatName( chatstate, name, client );
996 }
997
SV_BotResetGoalState(int goalstate)998 static void SV_BotResetGoalState( int goalstate ) {
999 botlib_export->ai.BotResetGoalState( goalstate );
1000 }
1001
SV_BotResetAvoidGoals(int goalstate)1002 static void SV_BotResetAvoidGoals( int goalstate ) {
1003 botlib_export->ai.BotResetAvoidGoals( goalstate );
1004 }
1005
SV_BotPushGoal(int goalstate,void * goal)1006 static void SV_BotPushGoal( int goalstate, void *goal ) {
1007 botlib_export->ai.BotPushGoal( goalstate, (bot_goal_s *)goal );
1008 }
1009
SV_BotPopGoal(int goalstate)1010 static void SV_BotPopGoal( int goalstate ) {
1011 botlib_export->ai.BotPopGoal( goalstate );
1012 }
1013
SV_BotEmptyGoalStack(int goalstate)1014 static void SV_BotEmptyGoalStack( int goalstate ) {
1015 botlib_export->ai.BotEmptyGoalStack( goalstate );
1016 }
1017
SV_BotDumpAvoidGoals(int goalstate)1018 static void SV_BotDumpAvoidGoals( int goalstate ) {
1019 botlib_export->ai.BotDumpAvoidGoals( goalstate );
1020 }
1021
SV_BotDumpGoalStack(int goalstate)1022 static void SV_BotDumpGoalStack( int goalstate ) {
1023 botlib_export->ai.BotDumpGoalStack( goalstate );
1024 }
1025
SV_BotGoalName(int number,char * name,int size)1026 static void SV_BotGoalName( int number, char *name, int size ) {
1027 botlib_export->ai.BotGoalName( number, name, size );
1028 }
1029
SV_BotGetTopGoal(int goalstate,void * goal)1030 static int SV_BotGetTopGoal( int goalstate, void *goal ) {
1031 return botlib_export->ai.BotGetTopGoal( goalstate, (bot_goal_s *)goal );
1032 }
1033
SV_BotGetSecondGoal(int goalstate,void * goal)1034 static int SV_BotGetSecondGoal( int goalstate, void *goal ) {
1035 return botlib_export->ai.BotGetSecondGoal( goalstate, (bot_goal_s *)goal );
1036 }
1037
SV_BotChooseLTGItem(int goalstate,vec3_t origin,int * inventory,int travelflags)1038 static int SV_BotChooseLTGItem( int goalstate, vec3_t origin, int *inventory, int travelflags ) {
1039 return botlib_export->ai.BotChooseLTGItem( goalstate, origin, inventory, travelflags );
1040 }
1041
SV_BotChooseNBGItem(int goalstate,vec3_t origin,int * inventory,int travelflags,void * ltg,float maxtime)1042 static int SV_BotChooseNBGItem( int goalstate, vec3_t origin, int *inventory, int travelflags, void *ltg, float maxtime ) {
1043 return botlib_export->ai.BotChooseNBGItem( goalstate, origin, inventory, travelflags, (bot_goal_s *)ltg, maxtime );
1044 }
1045
SV_BotTouchingGoal(vec3_t origin,void * goal)1046 static int SV_BotTouchingGoal( vec3_t origin, void *goal ) {
1047 return botlib_export->ai.BotTouchingGoal( origin, (bot_goal_s *)goal );
1048 }
1049
SV_BotItemGoalInVisButNotVisible(int viewer,vec3_t eye,vec3_t viewangles,void * goal)1050 static int SV_BotItemGoalInVisButNotVisible( int viewer, vec3_t eye, vec3_t viewangles, void *goal ) {
1051 return botlib_export->ai.BotItemGoalInVisButNotVisible( viewer, eye, viewangles, (bot_goal_s *)goal );
1052 }
1053
SV_BotGetLevelItemGoal(int index,char * classname,void * goal)1054 static int SV_BotGetLevelItemGoal( int index, char *classname, void *goal ) {
1055 return botlib_export->ai.BotGetLevelItemGoal( index, classname, (bot_goal_s *)goal );
1056 }
1057
SV_BotAvoidGoalTime(int goalstate,int number)1058 static float SV_BotAvoidGoalTime( int goalstate, int number ) {
1059 return botlib_export->ai.BotAvoidGoalTime( goalstate, number );
1060 }
1061
SV_BotInitLevelItems(void)1062 static void SV_BotInitLevelItems( void ) {
1063 botlib_export->ai.BotInitLevelItems();
1064 }
1065
SV_BotUpdateEntityItems(void)1066 static void SV_BotUpdateEntityItems( void ) {
1067 botlib_export->ai.BotUpdateEntityItems();
1068 }
1069
SV_BotLoadItemWeights(int goalstate,char * filename)1070 static int SV_BotLoadItemWeights( int goalstate, char *filename ) {
1071 return botlib_export->ai.BotLoadItemWeights( goalstate, filename );
1072 }
1073
SV_BotFreeItemWeights(int goalstate)1074 static void SV_BotFreeItemWeights( int goalstate ) {
1075 botlib_export->ai.BotFreeItemWeights( goalstate );
1076 }
1077
SV_BotSaveGoalFuzzyLogic(int goalstate,char * filename)1078 static void SV_BotSaveGoalFuzzyLogic( int goalstate, char *filename ) {
1079 botlib_export->ai.BotSaveGoalFuzzyLogic( goalstate, filename );
1080 }
1081
SV_BotAllocGoalState(int state)1082 static int SV_BotAllocGoalState( int state ) {
1083 return botlib_export->ai.BotAllocGoalState( state );
1084 }
1085
SV_BotFreeGoalState(int handle)1086 static void SV_BotFreeGoalState( int handle ) {
1087 botlib_export->ai.BotFreeGoalState( handle );
1088 }
1089
SV_BotResetMoveState(int movestate)1090 static void SV_BotResetMoveState( int movestate ) {
1091 botlib_export->ai.BotResetMoveState( movestate );
1092 }
1093
SV_BotMoveToGoal(void * result,int movestate,void * goal,int travelflags)1094 static void SV_BotMoveToGoal( void *result, int movestate, void *goal, int travelflags ) {
1095 botlib_export->ai.BotMoveToGoal( (bot_moveresult_s *)result, movestate, (bot_goal_s *)goal, travelflags );
1096 }
1097
SV_BotMoveInDirection(int movestate,vec3_t dir,float speed,int type)1098 static int SV_BotMoveInDirection( int movestate, vec3_t dir, float speed, int type ) {
1099 return botlib_export->ai.BotMoveInDirection( movestate, dir, speed, type );
1100 }
1101
SV_BotResetAvoidReach(int movestate)1102 static void SV_BotResetAvoidReach( int movestate ) {
1103 botlib_export->ai.BotResetAvoidReach( movestate );
1104 }
1105
SV_BotResetLastAvoidReach(int movestate)1106 static void SV_BotResetLastAvoidReach( int movestate ) {
1107 botlib_export->ai.BotResetLastAvoidReach( movestate );
1108 }
1109
SV_BotReachabilityArea(vec3_t origin,int testground)1110 static int SV_BotReachabilityArea( vec3_t origin, int testground ) {
1111 return botlib_export->ai.BotReachabilityArea( origin, testground );
1112 }
1113
SV_BotMovementViewTarget(int movestate,void * goal,int travelflags,float lookahead,vec3_t target)1114 static int SV_BotMovementViewTarget( int movestate, void *goal, int travelflags, float lookahead, vec3_t target ) {
1115 return botlib_export->ai.BotMovementViewTarget( movestate, (bot_goal_s *)goal, travelflags, lookahead, target );
1116 }
1117
SV_BotAllocMoveState(void)1118 static int SV_BotAllocMoveState( void ) {
1119 return botlib_export->ai.BotAllocMoveState();
1120 }
1121
SV_BotFreeMoveState(int handle)1122 static void SV_BotFreeMoveState( int handle ) {
1123 botlib_export->ai.BotFreeMoveState( handle );
1124 }
1125
SV_BotInitMoveState(int handle,void * initmove)1126 static void SV_BotInitMoveState( int handle, void *initmove ) {
1127 botlib_export->ai.BotInitMoveState( handle, (bot_initmove_s *)initmove );
1128 }
1129
SV_BotChooseBestFightWeapon(int weaponstate,int * inventory)1130 static int SV_BotChooseBestFightWeapon( int weaponstate, int *inventory ) {
1131 return botlib_export->ai.BotChooseBestFightWeapon( weaponstate, inventory );
1132 }
1133
SV_BotGetWeaponInfo(int weaponstate,int weapon,void * weaponinfo)1134 static void SV_BotGetWeaponInfo( int weaponstate, int weapon, void *weaponinfo ) {
1135 botlib_export->ai.BotGetWeaponInfo( weaponstate, weapon, (weaponinfo_s *)weaponinfo );
1136 }
1137
SV_BotLoadWeaponWeights(int weaponstate,char * filename)1138 static int SV_BotLoadWeaponWeights( int weaponstate, char *filename ) {
1139 return botlib_export->ai.BotLoadWeaponWeights( weaponstate, filename );
1140 }
1141
SV_BotAllocWeaponState(void)1142 static int SV_BotAllocWeaponState( void ) {
1143 return botlib_export->ai.BotAllocWeaponState();
1144 }
1145
SV_BotFreeWeaponState(int weaponstate)1146 static void SV_BotFreeWeaponState( int weaponstate ) {
1147 botlib_export->ai.BotFreeWeaponState( weaponstate );
1148 }
1149
SV_BotResetWeaponState(int weaponstate)1150 static void SV_BotResetWeaponState( int weaponstate ) {
1151 botlib_export->ai.BotResetWeaponState( weaponstate );
1152 }
1153
SV_GeneticParentsAndChildSelection(int numranks,float * ranks,int * parent1,int * parent2,int * child)1154 static int SV_GeneticParentsAndChildSelection( int numranks, float *ranks, int *parent1, int *parent2, int *child ) {
1155 return botlib_export->ai.GeneticParentsAndChildSelection( numranks, ranks, parent1, parent2, child );
1156 }
1157
SV_BotInterbreedGoalFuzzyLogic(int parent1,int parent2,int child)1158 static void SV_BotInterbreedGoalFuzzyLogic( int parent1, int parent2, int child ) {
1159 botlib_export->ai.BotInterbreedGoalFuzzyLogic( parent1, parent2, child );
1160 }
1161
SV_BotMutateGoalFuzzyLogic(int goalstate,float range)1162 static void SV_BotMutateGoalFuzzyLogic( int goalstate, float range ) {
1163 botlib_export->ai.BotMutateGoalFuzzyLogic( goalstate, range );
1164 }
1165
SV_BotGetNextCampSpotGoal(int num,void * goal)1166 static int SV_BotGetNextCampSpotGoal( int num, void *goal ) {
1167 return botlib_export->ai.BotGetNextCampSpotGoal( num, (bot_goal_s *)goal );
1168 }
1169
SV_BotGetMapLocationGoal(char * name,void * goal)1170 static int SV_BotGetMapLocationGoal( char *name, void *goal ) {
1171 return botlib_export->ai.BotGetMapLocationGoal( name, (bot_goal_s *)goal );
1172 }
1173
SV_BotNumInitialChats(int chatstate,char * type)1174 static int SV_BotNumInitialChats( int chatstate, char *type ) {
1175 return botlib_export->ai.BotNumInitialChats( chatstate, type );
1176 }
1177
SV_BotGetChatMessage(int chatstate,char * buf,int size)1178 static void SV_BotGetChatMessage( int chatstate, char *buf, int size ) {
1179 botlib_export->ai.BotGetChatMessage( chatstate, buf, size );
1180 }
1181
SV_BotRemoveFromAvoidGoals(int goalstate,int number)1182 static void SV_BotRemoveFromAvoidGoals( int goalstate, int number ) {
1183 botlib_export->ai.BotRemoveFromAvoidGoals( goalstate, number );
1184 }
1185
SV_BotPredictVisiblePosition(vec3_t origin,int areanum,void * goal,int travelflags,vec3_t target)1186 static int SV_BotPredictVisiblePosition( vec3_t origin, int areanum, void *goal, int travelflags, vec3_t target ) {
1187 return botlib_export->ai.BotPredictVisiblePosition( origin, areanum, (bot_goal_s *)goal, travelflags, target );
1188 }
1189
SV_BotSetAvoidGoalTime(int goalstate,int number,float avoidtime)1190 static void SV_BotSetAvoidGoalTime( int goalstate, int number, float avoidtime ) {
1191 botlib_export->ai.BotSetAvoidGoalTime( goalstate, number, avoidtime );
1192 }
1193
SV_BotAddAvoidSpot(int movestate,vec3_t origin,float radius,int type)1194 static void SV_BotAddAvoidSpot( int movestate, vec3_t origin, float radius, int type ) {
1195 botlib_export->ai.BotAddAvoidSpot( movestate, origin, radius, type );
1196 }
1197
SV_BotLibSetup(void)1198 static int SV_BotLibSetup( void ) {
1199 return botlib_export->BotLibSetup();
1200 }
1201
SV_BotLibShutdown(void)1202 static int SV_BotLibShutdown( void ) {
1203 return botlib_export->BotLibShutdown();
1204 }
1205
SV_BotLibVarSet(char * var_name,char * value)1206 static int SV_BotLibVarSet( char *var_name, char *value ) {
1207 return botlib_export->BotLibVarSet( var_name, value );
1208 }
1209
SV_BotLibVarGet(char * var_name,char * value,int size)1210 static int SV_BotLibVarGet( char *var_name, char *value, int size ) {
1211 return botlib_export->BotLibVarGet( var_name, value, size );
1212 }
1213
SV_BotLibDefine(char * string)1214 static int SV_BotLibDefine( char *string ) {
1215 return botlib_export->PC_AddGlobalDefine( string );
1216 }
1217
SV_BotLibStartFrame(float time)1218 static int SV_BotLibStartFrame( float time ) {
1219 return botlib_export->BotLibStartFrame( time );
1220 }
1221
SV_BotLibLoadMap(const char * mapname)1222 static int SV_BotLibLoadMap( const char *mapname ) {
1223 return botlib_export->BotLibLoadMap( mapname );
1224 }
1225
SV_BotLibUpdateEntity(int ent,void * bue)1226 static int SV_BotLibUpdateEntity( int ent, void *bue ) {
1227 return botlib_export->BotLibUpdateEntity( ent, (bot_entitystate_t *)bue );
1228 }
1229
SV_BotLibTest(int parm0,char * parm1,vec3_t parm2,vec3_t parm3)1230 static int SV_BotLibTest( int parm0, char *parm1, vec3_t parm2, vec3_t parm3 ) {
1231 return botlib_export->Test( parm0, parm1, parm2, parm3 );
1232 }
1233
SV_BotGetServerCommand(int clientNum,char * message,int size)1234 static int SV_BotGetServerCommand( int clientNum, char *message, int size ) {
1235 return SV_BotGetConsoleMessage( clientNum, message, size );
1236 }
1237
SV_BotUserCommand(int clientNum,usercmd_t * ucmd)1238 static void SV_BotUserCommand( int clientNum, usercmd_t *ucmd ) {
1239 SV_ClientThink( &svs.clients[clientNum], ucmd );
1240 }
1241
SV_AAS_EnableRoutingArea(int areanum,int enable)1242 static int SV_AAS_EnableRoutingArea( int areanum, int enable ) {
1243 return botlib_export->aas.AAS_EnableRoutingArea( areanum, enable );
1244 }
1245
SV_AAS_BBoxAreas(vec3_t absmins,vec3_t absmaxs,int * areas,int maxareas)1246 static int SV_AAS_BBoxAreas( vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas ) {
1247 return botlib_export->aas.AAS_BBoxAreas( absmins, absmaxs, areas, maxareas );
1248 }
1249
SV_AAS_AreaInfo(int areanum,void * info)1250 static int SV_AAS_AreaInfo( int areanum, void *info ) {
1251 return botlib_export->aas.AAS_AreaInfo( areanum, (aas_areainfo_s *)info );
1252 }
1253
SV_AAS_EntityInfo(int entnum,void * info)1254 static void SV_AAS_EntityInfo( int entnum, void *info ) {
1255 botlib_export->aas.AAS_EntityInfo( entnum, (aas_entityinfo_s *)info );
1256 }
1257
SV_AAS_Initialized(void)1258 static int SV_AAS_Initialized( void ) {
1259 return botlib_export->aas.AAS_Initialized();
1260 }
1261
SV_AAS_PresenceTypeBoundingBox(int presencetype,vec3_t mins,vec3_t maxs)1262 static void SV_AAS_PresenceTypeBoundingBox( int presencetype, vec3_t mins, vec3_t maxs ) {
1263 botlib_export->aas.AAS_PresenceTypeBoundingBox( presencetype, mins, maxs );
1264 }
1265
SV_AAS_Time(void)1266 static float SV_AAS_Time( void ) {
1267 return botlib_export->aas.AAS_Time();
1268 }
1269
SV_AAS_PointAreaNum(vec3_t point)1270 static int SV_AAS_PointAreaNum( vec3_t point ) {
1271 return botlib_export->aas.AAS_PointAreaNum( point );
1272 }
1273
SV_AAS_TraceAreas(vec3_t start,vec3_t end,int * areas,vec3_t * points,int maxareas)1274 static int SV_AAS_TraceAreas( vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas ) {
1275 return botlib_export->aas.AAS_TraceAreas( start, end, areas, points, maxareas );
1276 }
1277
SV_AAS_PointContents(vec3_t point)1278 static int SV_AAS_PointContents( vec3_t point ) {
1279 return botlib_export->aas.AAS_PointContents( point );
1280 }
1281
SV_AAS_NextBSPEntity(int ent)1282 static int SV_AAS_NextBSPEntity( int ent ) {
1283 return botlib_export->aas.AAS_NextBSPEntity( ent );
1284 }
1285
SV_AAS_ValueForBSPEpairKey(int ent,char * key,char * value,int size)1286 static int SV_AAS_ValueForBSPEpairKey( int ent, char *key, char *value, int size ) {
1287 return botlib_export->aas.AAS_ValueForBSPEpairKey( ent, key, value, size );
1288 }
1289
SV_AAS_VectorForBSPEpairKey(int ent,char * key,vec3_t v)1290 static int SV_AAS_VectorForBSPEpairKey( int ent, char *key, vec3_t v ) {
1291 return botlib_export->aas.AAS_VectorForBSPEpairKey( ent, key, v );
1292 }
1293
SV_AAS_FloatForBSPEpairKey(int ent,char * key,float * value)1294 static int SV_AAS_FloatForBSPEpairKey( int ent, char *key, float *value ) {
1295 return botlib_export->aas.AAS_FloatForBSPEpairKey( ent, key, value );
1296 }
1297
SV_AAS_IntForBSPEpairKey(int ent,char * key,int * value)1298 static int SV_AAS_IntForBSPEpairKey( int ent, char *key, int *value ) {
1299 return botlib_export->aas.AAS_IntForBSPEpairKey( ent, key, value );
1300 }
1301
SV_AAS_AreaReachability(int areanum)1302 static int SV_AAS_AreaReachability( int areanum ) {
1303 return botlib_export->aas.AAS_AreaReachability( areanum );
1304 }
1305
SV_AAS_AreaTravelTimeToGoalArea(int areanum,vec3_t origin,int goalareanum,int travelflags)1306 static int SV_AAS_AreaTravelTimeToGoalArea( int areanum, vec3_t origin, int goalareanum, int travelflags ) {
1307 return botlib_export->aas.AAS_AreaTravelTimeToGoalArea( areanum, origin, goalareanum, travelflags );
1308 }
1309
SV_AAS_Swimming(vec3_t origin)1310 static int SV_AAS_Swimming( vec3_t origin ) {
1311 return botlib_export->aas.AAS_Swimming( origin );
1312 }
1313
SV_AAS_PredictClientMovement(void * move,int entnum,vec3_t origin,int presencetype,int onground,vec3_t velocity,vec3_t cmdmove,int cmdframes,int maxframes,float frametime,int stopevent,int stopareanum,int visualize)1314 static int SV_AAS_PredictClientMovement( void *move, int entnum, vec3_t origin, int presencetype, int onground, vec3_t velocity, vec3_t cmdmove, int cmdframes, int maxframes, float frametime, int stopevent, int stopareanum, int visualize ) {
1315 return botlib_export->aas.AAS_PredictClientMovement( (aas_clientmove_s *)move, entnum, origin, presencetype, onground, velocity, cmdmove, cmdframes, maxframes, frametime, stopevent, stopareanum, visualize );
1316 }
1317
SV_AAS_AlternativeRouteGoals(vec3_t start,int startareanum,vec3_t goal,int goalareanum,int travelflags,void * altroutegoals,int maxaltroutegoals,int type)1318 static int SV_AAS_AlternativeRouteGoals( vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags, void *altroutegoals, int maxaltroutegoals, int type ) {
1319 return botlib_export->aas.AAS_AlternativeRouteGoals( start, startareanum, goal, goalareanum, travelflags, (aas_altroutegoal_s *)altroutegoals, maxaltroutegoals, type );
1320 }
1321
SV_AAS_PredictRoute(void * route,int areanum,vec3_t origin,int goalareanum,int travelflags,int maxareas,int maxtime,int stopevent,int stopcontents,int stoptfl,int stopareanum)1322 static int SV_AAS_PredictRoute( void *route, int areanum, vec3_t origin, int goalareanum, int travelflags, int maxareas, int maxtime, int stopevent, int stopcontents, int stoptfl, int stopareanum ) {
1323 return botlib_export->aas.AAS_PredictRoute( (aas_predictroute_s *)route, areanum, origin, goalareanum, travelflags, maxareas, maxtime, stopevent, stopcontents, stoptfl, stopareanum );
1324 }
1325
SV_AAS_PointReachabilityAreaIndex(vec3_t point)1326 static int SV_AAS_PointReachabilityAreaIndex( vec3_t point ) {
1327 return botlib_export->aas.AAS_PointReachabilityAreaIndex( point );
1328 }
1329
SV_EA_Say(int client,char * str)1330 static void SV_EA_Say( int client, char *str ) {
1331 botlib_export->ea.EA_Say( client, str );
1332 }
1333
SV_EA_SayTeam(int client,char * str)1334 static void SV_EA_SayTeam( int client, char *str ) {
1335 botlib_export->ea.EA_SayTeam( client, str );
1336 }
1337
SV_EA_Command(int client,char * command)1338 static void SV_EA_Command( int client, char *command ) {
1339 botlib_export->ea.EA_Command( client, command );
1340 }
1341
SV_EA_Action(int client,int action)1342 static void SV_EA_Action( int client, int action ) {
1343 botlib_export->ea.EA_Action( client, action );
1344 }
1345
SV_EA_Gesture(int client)1346 static void SV_EA_Gesture( int client ) {
1347 botlib_export->ea.EA_Gesture( client );
1348 }
1349
SV_EA_Talk(int client)1350 static void SV_EA_Talk( int client ) {
1351 botlib_export->ea.EA_Talk( client );
1352 }
1353
SV_EA_Attack(int client)1354 static void SV_EA_Attack( int client ) {
1355 botlib_export->ea.EA_Attack( client );
1356 }
1357
SV_EA_Alt_Attack(int client)1358 static void SV_EA_Alt_Attack( int client ) {
1359 botlib_export->ea.EA_Alt_Attack( client );
1360 }
1361
SV_EA_ForcePower(int client)1362 static void SV_EA_ForcePower( int client ) {
1363 botlib_export->ea.EA_ForcePower( client );
1364 }
1365
SV_EA_Use(int client)1366 static void SV_EA_Use( int client ) {
1367 botlib_export->ea.EA_Use( client );
1368 }
1369
SV_EA_Respawn(int client)1370 static void SV_EA_Respawn( int client ) {
1371 botlib_export->ea.EA_Respawn( client );
1372 }
1373
SV_EA_Crouch(int client)1374 static void SV_EA_Crouch( int client ) {
1375 botlib_export->ea.EA_Crouch( client );
1376 }
1377
SV_EA_MoveUp(int client)1378 static void SV_EA_MoveUp( int client ) {
1379 botlib_export->ea.EA_MoveUp( client );
1380 }
1381
SV_EA_MoveDown(int client)1382 static void SV_EA_MoveDown( int client ) {
1383 botlib_export->ea.EA_MoveDown( client );
1384 }
1385
SV_EA_MoveForward(int client)1386 static void SV_EA_MoveForward( int client ) {
1387 botlib_export->ea.EA_MoveForward( client );
1388 }
1389
SV_EA_MoveBack(int client)1390 static void SV_EA_MoveBack( int client ) {
1391 botlib_export->ea.EA_MoveBack( client );
1392 }
1393
SV_EA_MoveLeft(int client)1394 static void SV_EA_MoveLeft( int client ) {
1395 botlib_export->ea.EA_MoveLeft( client );
1396 }
1397
SV_EA_MoveRight(int client)1398 static void SV_EA_MoveRight( int client ) {
1399 botlib_export->ea.EA_MoveRight( client );
1400 }
1401
SV_EA_SelectWeapon(int client,int weapon)1402 static void SV_EA_SelectWeapon( int client, int weapon ) {
1403 botlib_export->ea.EA_SelectWeapon( client, weapon );
1404 }
1405
SV_EA_Jump(int client)1406 static void SV_EA_Jump( int client ) {
1407 botlib_export->ea.EA_Jump( client );
1408 }
1409
SV_EA_DelayedJump(int client)1410 static void SV_EA_DelayedJump( int client ) {
1411 botlib_export->ea.EA_DelayedJump( client );
1412 }
1413
SV_EA_Move(int client,vec3_t dir,float speed)1414 static void SV_EA_Move( int client, vec3_t dir, float speed ) {
1415 botlib_export->ea.EA_Move( client, dir, speed );
1416 }
1417
SV_EA_View(int client,vec3_t viewangles)1418 static void SV_EA_View( int client, vec3_t viewangles ) {
1419 botlib_export->ea.EA_View( client, viewangles );
1420 }
1421
SV_EA_EndRegular(int client,float thinktime)1422 static void SV_EA_EndRegular( int client, float thinktime ) {
1423 botlib_export->ea.EA_EndRegular( client, thinktime );
1424 }
1425
SV_EA_GetInput(int client,float thinktime,void * input)1426 static void SV_EA_GetInput( int client, float thinktime, void *input ) {
1427 botlib_export->ea.EA_GetInput( client, thinktime, (bot_input_t *)input );
1428 }
1429
SV_EA_ResetInput(int client)1430 static void SV_EA_ResetInput( int client ) {
1431 botlib_export->ea.EA_ResetInput( client );
1432 }
1433
SV_PC_LoadSource(const char * filename)1434 static int SV_PC_LoadSource( const char *filename ) {
1435 return botlib_export->PC_LoadSourceHandle( filename );
1436 }
1437
SV_PC_FreeSource(int handle)1438 static int SV_PC_FreeSource( int handle ) {
1439 return botlib_export->PC_FreeSourceHandle( handle );
1440 }
1441
SV_PC_ReadToken(int handle,pc_token_t * pc_token)1442 static int SV_PC_ReadToken( int handle, pc_token_t *pc_token ) {
1443 return botlib_export->PC_ReadTokenHandle( handle, pc_token );
1444 }
1445
SV_PC_SourceFileAndLine(int handle,char * filename,int * line)1446 static int SV_PC_SourceFileAndLine( int handle, char *filename, int *line ) {
1447 return botlib_export->PC_SourceFileAndLine( handle, filename, line );
1448 }
1449
SV_RE_RegisterSkin(const char * name)1450 static qhandle_t SV_RE_RegisterSkin( const char *name ) {
1451 return re->RegisterServerSkin( name );
1452 }
1453
SV_CM_RegisterTerrain(const char * config)1454 static int SV_CM_RegisterTerrain( const char *config ) {
1455 return 0;
1456 }
1457
SV_RMG_Init(void)1458 static void SV_RMG_Init( void ) { }
1459
SV_G2API_ListModelSurfaces(void * ghlInfo)1460 static void SV_G2API_ListModelSurfaces( void *ghlInfo ) {
1461 re->G2API_ListSurfaces( (CGhoul2Info *)ghlInfo );
1462 }
1463
SV_G2API_ListModelBones(void * ghlInfo,int frame)1464 static void SV_G2API_ListModelBones( void *ghlInfo, int frame ) {
1465 re->G2API_ListBones( (CGhoul2Info *)ghlInfo, frame );
1466 }
1467
SV_G2API_SetGhoul2ModelIndexes(void * ghoul2,qhandle_t * modelList,qhandle_t * skinList)1468 static void SV_G2API_SetGhoul2ModelIndexes( void *ghoul2, qhandle_t *modelList, qhandle_t *skinList ) {
1469 if ( !ghoul2 ) return;
1470 re->G2API_SetGhoul2ModelIndexes( *((CGhoul2Info_v *)ghoul2), modelList, skinList );
1471 }
1472
SV_G2API_HaveWeGhoul2Models(void * ghoul2)1473 static qboolean SV_G2API_HaveWeGhoul2Models( void *ghoul2) {
1474 if ( !ghoul2 ) return qfalse;
1475 return re->G2API_HaveWeGhoul2Models( *((CGhoul2Info_v *)ghoul2) );
1476 }
1477
SV_G2API_GetBoltMatrix(void * ghoul2,const int modelIndex,const int boltIndex,mdxaBone_t * matrix,const vec3_t angles,const vec3_t position,const int frameNum,qhandle_t * modelList,vec3_t scale)1478 static qboolean SV_G2API_GetBoltMatrix( void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix, const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale ) {
1479 if ( !ghoul2 ) return qfalse;
1480 return re->G2API_GetBoltMatrix( *((CGhoul2Info_v *)ghoul2), modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale );
1481 }
1482
SV_G2API_GetBoltMatrix_NoReconstruct(void * ghoul2,const int modelIndex,const int boltIndex,mdxaBone_t * matrix,const vec3_t angles,const vec3_t position,const int frameNum,qhandle_t * modelList,vec3_t scale)1483 static qboolean SV_G2API_GetBoltMatrix_NoReconstruct( void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix, const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale ) {
1484 if ( !ghoul2 ) return qfalse;
1485 re->G2API_BoltMatrixReconstruction( qfalse );
1486 return re->G2API_GetBoltMatrix( *((CGhoul2Info_v *)ghoul2), modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale );
1487 }
1488
SV_G2API_GetBoltMatrix_NoRecNoRot(void * ghoul2,const int modelIndex,const int boltIndex,mdxaBone_t * matrix,const vec3_t angles,const vec3_t position,const int frameNum,qhandle_t * modelList,vec3_t scale)1489 static qboolean SV_G2API_GetBoltMatrix_NoRecNoRot( void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix, const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale ) {
1490 if ( !ghoul2 ) return qfalse;
1491 re->G2API_BoltMatrixReconstruction( qfalse );
1492 re->G2API_BoltMatrixSPMethod( qtrue );
1493 return re->G2API_GetBoltMatrix( *((CGhoul2Info_v *)ghoul2), modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale );
1494 }
1495
SV_G2API_InitGhoul2Model(void ** ghoul2Ptr,const char * fileName,int modelIndex,qhandle_t customSkin,qhandle_t customShader,int modelFlags,int lodBias)1496 static int SV_G2API_InitGhoul2Model( void **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin, qhandle_t customShader, int modelFlags, int lodBias ) {
1497 #ifdef _FULL_G2_LEAK_CHECKING
1498 g_G2AllocServer = 1;
1499 #endif
1500 return re->G2API_InitGhoul2Model( (CGhoul2Info_v **)ghoul2Ptr, fileName, modelIndex, customSkin, customShader, modelFlags, lodBias );
1501 }
1502
SV_G2API_SetSkin(void * ghoul2,int modelIndex,qhandle_t customSkin,qhandle_t renderSkin)1503 static qboolean SV_G2API_SetSkin( void *ghoul2, int modelIndex, qhandle_t customSkin, qhandle_t renderSkin ) {
1504 if ( !ghoul2 ) return qfalse;
1505 CGhoul2Info_v &g2 = *((CGhoul2Info_v *)ghoul2);
1506 return re->G2API_SetSkin( g2, modelIndex, customSkin, renderSkin );
1507 }
1508
SV_G2API_CollisionDetect(CollisionRecord_t * collRecMap,void * ghoul2,const vec3_t angles,const vec3_t position,int frameNumber,int entNum,vec3_t rayStart,vec3_t rayEnd,vec3_t scale,int traceFlags,int useLod,float fRadius)1509 static void SV_G2API_CollisionDetect( CollisionRecord_t *collRecMap, void* ghoul2, const vec3_t angles, const vec3_t position, int frameNumber, int entNum, vec3_t rayStart, vec3_t rayEnd, vec3_t scale, int traceFlags, int useLod, float fRadius ) {
1510 if ( !ghoul2 ) return;
1511 re->G2API_CollisionDetect( collRecMap, *((CGhoul2Info_v *)ghoul2), angles, position, frameNumber, entNum, rayStart, rayEnd, scale, G2VertSpaceServer, traceFlags, useLod, fRadius );
1512 }
1513
SV_G2API_CollisionDetectCache(CollisionRecord_t * collRecMap,void * ghoul2,const vec3_t angles,const vec3_t position,int frameNumber,int entNum,vec3_t rayStart,vec3_t rayEnd,vec3_t scale,int traceFlags,int useLod,float fRadius)1514 static void SV_G2API_CollisionDetectCache( CollisionRecord_t *collRecMap, void* ghoul2, const vec3_t angles, const vec3_t position, int frameNumber, int entNum, vec3_t rayStart, vec3_t rayEnd, vec3_t scale, int traceFlags, int useLod, float fRadius ) {
1515 if ( !ghoul2 ) return;
1516 re->G2API_CollisionDetectCache( collRecMap, *((CGhoul2Info_v *)ghoul2), angles, position, frameNumber, entNum, rayStart, rayEnd, scale, G2VertSpaceServer, traceFlags, useLod, fRadius );
1517 }
1518
SV_G2API_CleanGhoul2Models(void ** ghoul2Ptr)1519 static void SV_G2API_CleanGhoul2Models( void **ghoul2Ptr ) {
1520 #ifdef _FULL_G2_LEAK_CHECKING
1521 g_G2AllocServer = 1;
1522 #endif
1523 re->G2API_CleanGhoul2Models( (CGhoul2Info_v **)ghoul2Ptr );
1524 }
1525
SV_G2API_SetBoneAngles(void * ghoul2,int modelIndex,const char * boneName,const vec3_t angles,const int flags,const int up,const int right,const int forward,qhandle_t * modelList,int blendTime,int currentTime)1526 static qboolean SV_G2API_SetBoneAngles( void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags, const int up, const int right, const int forward, qhandle_t *modelList, int blendTime , int currentTime ) {
1527 if ( !ghoul2 ) return qfalse;
1528 return re->G2API_SetBoneAngles( *((CGhoul2Info_v *)ghoul2), modelIndex, boneName, angles, flags, (const Eorientations)up, (const Eorientations)right, (const Eorientations)forward, modelList, blendTime , currentTime );
1529 }
1530
SV_G2API_SetBoneAnim(void * ghoul2,const int modelIndex,const char * boneName,const int startFrame,const int endFrame,const int flags,const float animSpeed,const int currentTime,const float setFrame,const int blendTime)1531 static qboolean SV_G2API_SetBoneAnim( void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame, const int blendTime ) {
1532 if ( !ghoul2 ) return qfalse;
1533 return re->G2API_SetBoneAnim( *((CGhoul2Info_v *)ghoul2), modelIndex, boneName, startFrame, endFrame, flags, animSpeed, currentTime, setFrame, blendTime );
1534 }
1535
SV_G2API_GetBoneAnim(void * ghoul2,const char * boneName,const int currentTime,float * currentFrame,int * startFrame,int * endFrame,int * flags,float * animSpeed,int * modelList,const int modelIndex)1536 static qboolean SV_G2API_GetBoneAnim( void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *startFrame, int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex ) {
1537 if ( !ghoul2 ) return qfalse;
1538 CGhoul2Info_v &g2 = *((CGhoul2Info_v *)ghoul2);
1539 return re->G2API_GetBoneAnim( g2, modelIndex, boneName, currentTime, currentFrame, startFrame, endFrame, flags, animSpeed, modelList );
1540 }
1541
SV_G2API_GetGLAName(void * ghoul2,int modelIndex,char * fillBuf)1542 static void SV_G2API_GetGLAName( void *ghoul2, int modelIndex, char *fillBuf ) {
1543 if ( !ghoul2 )
1544 {
1545 fillBuf[0] = '\0';
1546 return;
1547 }
1548
1549 char *tmp = re->G2API_GetGLAName( *((CGhoul2Info_v *)ghoul2), modelIndex );
1550 if ( tmp )
1551 strcpy( fillBuf, tmp );
1552 else
1553 fillBuf[0] = '\0';
1554 }
1555
SV_G2API_CopyGhoul2Instance(void * g2From,void * g2To,int modelIndex)1556 static int SV_G2API_CopyGhoul2Instance( void *g2From, void *g2To, int modelIndex ) {
1557 if ( !g2From || !g2To ) return 0;
1558 return re->G2API_CopyGhoul2Instance( *((CGhoul2Info_v *)g2From), *((CGhoul2Info_v *)g2To), modelIndex );
1559 }
1560
SV_G2API_CopySpecificGhoul2Model(void * g2From,int modelFrom,void * g2To,int modelTo)1561 static void SV_G2API_CopySpecificGhoul2Model( void *g2From, int modelFrom, void *g2To, int modelTo ) {
1562 if ( !g2From || !g2To ) return;
1563 re->G2API_CopySpecificG2Model( *((CGhoul2Info_v *)g2From), modelFrom, *((CGhoul2Info_v *)g2To), modelTo );
1564 }
1565
SV_G2API_DuplicateGhoul2Instance(void * g2From,void ** g2To)1566 static void SV_G2API_DuplicateGhoul2Instance( void *g2From, void **g2To ) {
1567 #ifdef _FULL_G2_LEAK_CHECKING
1568 g_G2AllocServer = 1;
1569 #endif
1570 if ( !g2From || !g2To ) return;
1571 re->G2API_DuplicateGhoul2Instance( *((CGhoul2Info_v *)g2From), (CGhoul2Info_v **)g2To );
1572 }
1573
SV_G2API_HasGhoul2ModelOnIndex(void * ghlInfo,int modelIndex)1574 static qboolean SV_G2API_HasGhoul2ModelOnIndex( void *ghlInfo, int modelIndex ) {
1575 return re->G2API_HasGhoul2ModelOnIndex( (CGhoul2Info_v **)ghlInfo, modelIndex );
1576 }
1577
SV_G2API_RemoveGhoul2Model(void * ghlInfo,int modelIndex)1578 static qboolean SV_G2API_RemoveGhoul2Model( void *ghlInfo, int modelIndex ) {
1579 #ifdef _FULL_G2_LEAK_CHECKING
1580 g_G2AllocServer = 1;
1581 #endif
1582 return re->G2API_RemoveGhoul2Model( (CGhoul2Info_v **)ghlInfo, modelIndex );
1583 }
1584
SV_G2API_RemoveGhoul2Models(void * ghlInfo)1585 static qboolean SV_G2API_RemoveGhoul2Models( void *ghlInfo ) {
1586 #ifdef _FULL_G2_LEAK_CHECKING
1587 g_G2AllocServer = 1;
1588 #endif
1589 return re->G2API_RemoveGhoul2Models( (CGhoul2Info_v **)ghlInfo );
1590 }
1591
SV_G2API_Ghoul2Size(void * ghlInfo)1592 static int SV_G2API_Ghoul2Size( void *ghlInfo ) {
1593 if ( !ghlInfo ) return 0;
1594 return re->G2API_Ghoul2Size( *((CGhoul2Info_v *)ghlInfo) );
1595 }
1596
SV_G2API_AddBolt(void * ghoul2,int modelIndex,const char * boneName)1597 static int SV_G2API_AddBolt( void *ghoul2, int modelIndex, const char *boneName ) {
1598 if ( !ghoul2 ) return -1;
1599 return re->G2API_AddBolt( *((CGhoul2Info_v *)ghoul2), modelIndex, boneName );
1600 }
1601
SV_G2API_SetBoltInfo(void * ghoul2,int modelIndex,int boltInfo)1602 static void SV_G2API_SetBoltInfo( void *ghoul2, int modelIndex, int boltInfo ) {
1603 if ( !ghoul2 ) return;
1604 re->G2API_SetBoltInfo( *((CGhoul2Info_v *)ghoul2), modelIndex, boltInfo );
1605 }
1606
SV_G2API_SetRootSurface(void * ghoul2,const int modelIndex,const char * surfaceName)1607 static qboolean SV_G2API_SetRootSurface( void *ghoul2, const int modelIndex, const char *surfaceName ) {
1608 if ( !ghoul2 ) return qfalse;
1609 return re->G2API_SetRootSurface( *((CGhoul2Info_v *)ghoul2), modelIndex, surfaceName );
1610 }
1611
SV_G2API_SetSurfaceOnOff(void * ghoul2,const char * surfaceName,const int flags)1612 static qboolean SV_G2API_SetSurfaceOnOff( void *ghoul2, const char *surfaceName, const int flags ) {
1613 if ( !ghoul2 ) return qfalse;
1614 return re->G2API_SetSurfaceOnOff( *((CGhoul2Info_v *)ghoul2), surfaceName, flags );
1615 }
1616
SV_G2API_SetNewOrigin(void * ghoul2,const int boltIndex)1617 static qboolean SV_G2API_SetNewOrigin( void *ghoul2, const int boltIndex ) {
1618 if ( !ghoul2 ) return qfalse;
1619 return re->G2API_SetNewOrigin( *((CGhoul2Info_v *)ghoul2), boltIndex );
1620 }
1621
SV_G2API_DoesBoneExist(void * ghoul2,int modelIndex,const char * boneName)1622 static qboolean SV_G2API_DoesBoneExist( void *ghoul2, int modelIndex, const char *boneName ) {
1623 if ( !ghoul2 ) return qfalse;
1624 CGhoul2Info_v &g2 = *((CGhoul2Info_v *)ghoul2);
1625 return re->G2API_DoesBoneExist( g2, modelIndex, boneName );
1626 }
1627
SV_G2API_GetSurfaceRenderStatus(void * ghoul2,const int modelIndex,const char * surfaceName)1628 static int SV_G2API_GetSurfaceRenderStatus( void *ghoul2, const int modelIndex, const char *surfaceName ) {
1629 if ( !ghoul2 ) return -1;
1630 CGhoul2Info_v &g2 = *((CGhoul2Info_v *)ghoul2);
1631 return re->G2API_GetSurfaceRenderStatus( g2, modelIndex, surfaceName );
1632 }
1633
SV_G2API_AbsurdSmoothing(void * ghoul2,qboolean status)1634 static void SV_G2API_AbsurdSmoothing( void *ghoul2, qboolean status ) {
1635 if ( !ghoul2 ) return;
1636 CGhoul2Info_v &g2 = *((CGhoul2Info_v *)ghoul2);
1637 re->G2API_AbsurdSmoothing( g2, status );
1638 }
1639
SV_G2API_SetRagDoll(void * ghoul2,sharedRagDollParams_t * params)1640 static void SV_G2API_SetRagDoll( void *ghoul2, sharedRagDollParams_t *params ) {
1641 if ( !ghoul2 ) return;
1642
1643 CRagDollParams rdParams;
1644
1645 if ( !params ) {
1646 re->G2API_ResetRagDoll( *((CGhoul2Info_v *)ghoul2) );
1647 return;
1648 }
1649
1650 VectorCopy( params->angles, rdParams.angles );
1651 VectorCopy( params->position, rdParams.position );
1652 VectorCopy( params->scale, rdParams.scale );
1653 VectorCopy( params->pelvisAnglesOffset, rdParams.pelvisAnglesOffset );
1654 VectorCopy( params->pelvisPositionOffset, rdParams.pelvisPositionOffset );
1655
1656 rdParams.fImpactStrength = params->fImpactStrength;
1657 rdParams.fShotStrength = params->fShotStrength;
1658 rdParams.me = params->me;
1659
1660 rdParams.startFrame = params->startFrame;
1661 rdParams.endFrame = params->endFrame;
1662
1663 rdParams.collisionType = params->collisionType;
1664 rdParams.CallRagDollBegin = params->CallRagDollBegin;
1665
1666 rdParams.RagPhase = (CRagDollParams::ERagPhase)params->RagPhase;
1667 rdParams.effectorsToTurnOff = (CRagDollParams::ERagEffector)params->effectorsToTurnOff;
1668
1669 re->G2API_SetRagDoll( *((CGhoul2Info_v *)ghoul2), &rdParams );
1670 }
1671
SV_G2API_AnimateG2Models(void * ghoul2,int time,sharedRagDollUpdateParams_t * params)1672 static void SV_G2API_AnimateG2Models( void *ghoul2, int time, sharedRagDollUpdateParams_t *params ) {
1673 CRagDollUpdateParams rduParams;
1674
1675 if ( !params )
1676 return;
1677
1678 VectorCopy( params->angles, rduParams.angles );
1679 VectorCopy( params->position, rduParams.position );
1680 VectorCopy( params->scale, rduParams.scale );
1681 VectorCopy( params->velocity, rduParams.velocity );
1682
1683 rduParams.me = params->me;
1684 rduParams.settleFrame = params->settleFrame;
1685
1686 re->G2API_AnimateG2ModelsRag( *((CGhoul2Info_v *)ghoul2), time, &rduParams );
1687 }
1688
SV_G2API_RagPCJConstraint(void * ghoul2,const char * boneName,vec3_t min,vec3_t max)1689 static qboolean SV_G2API_RagPCJConstraint( void *ghoul2, const char *boneName, vec3_t min, vec3_t max ) {
1690 return re->G2API_RagPCJConstraint( *((CGhoul2Info_v *)ghoul2), boneName, min, max );
1691 }
1692
SV_G2API_RagPCJGradientSpeed(void * ghoul2,const char * boneName,const float speed)1693 static qboolean SV_G2API_RagPCJGradientSpeed( void *ghoul2, const char *boneName, const float speed ) {
1694 return re->G2API_RagPCJGradientSpeed( *((CGhoul2Info_v *)ghoul2), boneName, speed );
1695 }
1696
SV_G2API_RagEffectorGoal(void * ghoul2,const char * boneName,vec3_t pos)1697 static qboolean SV_G2API_RagEffectorGoal( void *ghoul2, const char *boneName, vec3_t pos ) {
1698 return re->G2API_RagEffectorGoal( *((CGhoul2Info_v *)ghoul2), boneName, pos );
1699 }
1700
SV_G2API_GetRagBonePos(void * ghoul2,const char * boneName,vec3_t pos,vec3_t entAngles,vec3_t entPos,vec3_t entScale)1701 static qboolean SV_G2API_GetRagBonePos( void *ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale ) {
1702 return re->G2API_GetRagBonePos( *((CGhoul2Info_v *)ghoul2), boneName, pos, entAngles, entPos, entScale );
1703 }
1704
SV_G2API_RagEffectorKick(void * ghoul2,const char * boneName,vec3_t velocity)1705 static qboolean SV_G2API_RagEffectorKick( void *ghoul2, const char *boneName, vec3_t velocity ) {
1706 return re->G2API_RagEffectorKick( *((CGhoul2Info_v *)ghoul2), boneName, velocity );
1707 }
1708
SV_G2API_RagForceSolve(void * ghoul2,qboolean force)1709 static qboolean SV_G2API_RagForceSolve( void *ghoul2, qboolean force ) {
1710 return re->G2API_RagForceSolve( *((CGhoul2Info_v *)ghoul2), force );
1711 }
1712
SV_G2API_SetBoneIKState(void * ghoul2,int time,const char * boneName,int ikState,sharedSetBoneIKStateParams_t * params)1713 static qboolean SV_G2API_SetBoneIKState( void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params ) {
1714 return re->G2API_SetBoneIKState( *((CGhoul2Info_v *)ghoul2), time, boneName, ikState, params );
1715 }
1716
SV_G2API_IKMove(void * ghoul2,int time,sharedIKMoveParams_t * params)1717 static qboolean SV_G2API_IKMove( void *ghoul2, int time, sharedIKMoveParams_t *params ) {
1718 return re->G2API_IKMove( *((CGhoul2Info_v *)ghoul2), time, params );
1719 }
1720
SV_G2API_RemoveBone(void * ghoul2,const char * boneName,int modelIndex)1721 static qboolean SV_G2API_RemoveBone( void *ghoul2, const char *boneName, int modelIndex ) {
1722 CGhoul2Info_v &g2 = *((CGhoul2Info_v *)ghoul2);
1723 return re->G2API_RemoveBone( g2, modelIndex, boneName );
1724 }
1725
SV_G2API_AttachInstanceToEntNum(void * ghoul2,int entityNum,qboolean server)1726 static void SV_G2API_AttachInstanceToEntNum( void *ghoul2, int entityNum, qboolean server ) {
1727 re->G2API_AttachInstanceToEntNum( *((CGhoul2Info_v *)ghoul2), entityNum, server );
1728 }
1729
SV_G2API_ClearAttachedInstance(int entityNum)1730 static void SV_G2API_ClearAttachedInstance( int entityNum ) {
1731 re->G2API_ClearAttachedInstance( entityNum );
1732 }
1733
SV_G2API_CleanEntAttachments(void)1734 static void SV_G2API_CleanEntAttachments( void ) {
1735 re->G2API_CleanEntAttachments();
1736 }
1737
SV_G2API_OverrideServer(void * serverInstance)1738 static qboolean SV_G2API_OverrideServer( void *serverInstance ) {
1739 CGhoul2Info_v &g2 = *((CGhoul2Info_v *)serverInstance);
1740 return re->G2API_OverrideServerWithClientData( g2, 0 );
1741 }
1742
SV_G2API_GetSurfaceName(void * ghoul2,int surfNumber,int modelIndex,char * fillBuf)1743 static void SV_G2API_GetSurfaceName( void *ghoul2, int surfNumber, int modelIndex, char *fillBuf ) {
1744 CGhoul2Info_v &g2 = *((CGhoul2Info_v *)ghoul2);
1745 char *tmp = re->G2API_GetSurfaceName( g2, modelIndex, surfNumber );
1746 strcpy( fillBuf, tmp );
1747 }
1748
GVM_Cvar_Set(const char * var_name,const char * value)1749 static void GVM_Cvar_Set( const char *var_name, const char *value ) {
1750 Cvar_VM_Set( var_name, value, VM_GAME );
1751 }
1752
1753 // legacy syscall
1754
SV_GameSystemCalls(intptr_t * args)1755 intptr_t SV_GameSystemCalls( intptr_t *args ) {
1756 switch( args[0] ) {
1757
1758 //rww - alright, DO NOT EVER add a game/cgame/ui generic call without adding a trap to match, and
1759 //all of these traps must be shared and have cases in sv_game, cl_cgame, and cl_ui. They must also
1760 //all be in the same order, and start at 100.
1761 case TRAP_MEMSET:
1762 Com_Memset( VMA(1), args[2], args[3] );
1763 return 0;
1764
1765 case TRAP_MEMCPY:
1766 Com_Memcpy( VMA(1), VMA(2), args[3] );
1767 return 0;
1768
1769 case TRAP_STRNCPY:
1770 strncpy( (char *)VMA(1), (const char *)VMA(2), args[3] );
1771 return args[1];
1772
1773 case TRAP_SIN:
1774 return FloatAsInt( sin( VMF(1) ) );
1775
1776 case TRAP_COS:
1777 return FloatAsInt( cos( VMF(1) ) );
1778
1779 case TRAP_ATAN2:
1780 return FloatAsInt( atan2( VMF(1), VMF(2) ) );
1781
1782 case TRAP_SQRT:
1783 return FloatAsInt( sqrt( VMF(1) ) );
1784
1785 case TRAP_MATRIXMULTIPLY:
1786 MatrixMultiply( (vec3_t *)VMA(1), (vec3_t *)VMA(2), (vec3_t *)VMA(3) );
1787 return 0;
1788
1789 case TRAP_ANGLEVECTORS:
1790 AngleVectors( (const float *)VMA(1), (float *)VMA(2), (float *)VMA(3), (float *)VMA(4) );
1791 return 0;
1792
1793 case TRAP_PERPENDICULARVECTOR:
1794 PerpendicularVector( (float *)VMA(1), (const float *)VMA(2) );
1795 return 0;
1796
1797 case TRAP_FLOOR:
1798 return FloatAsInt( floor( VMF(1) ) );
1799
1800 case TRAP_CEIL:
1801 return FloatAsInt( ceil( VMF(1) ) );
1802
1803 case TRAP_TESTPRINTINT:
1804 return 0;
1805
1806 case TRAP_TESTPRINTFLOAT:
1807 return 0;
1808
1809 case TRAP_ACOS:
1810 return FloatAsInt( Q_acos( VMF(1) ) );
1811
1812 case TRAP_ASIN:
1813 return FloatAsInt( Q_asin( VMF(1) ) );
1814
1815 case G_PRINT:
1816 Com_Printf( "%s", VMA(1) );
1817 return 0;
1818
1819 case G_ERROR:
1820 Com_Error( ERR_DROP, "%s", VMA(1) );
1821 return 0;
1822
1823 case G_MILLISECONDS:
1824 return Sys_Milliseconds();
1825
1826 case G_PRECISIONTIMER_START:
1827 SV_PrecisionTimerStart( (void **)VMA(1) );
1828 return 0;
1829
1830 case G_PRECISIONTIMER_END:
1831 return SV_PrecisionTimerEnd( (void *)args[1] );
1832
1833 case G_CVAR_REGISTER:
1834 Cvar_Register( (vmCvar_t *)VMA(1), (const char *)VMA(2), (const char *)VMA(3), args[4] );
1835 return 0;
1836
1837 case G_CVAR_UPDATE:
1838 Cvar_Update( (vmCvar_t *)VMA(1) );
1839 return 0;
1840
1841 case G_CVAR_SET:
1842 Cvar_VM_Set( (const char *)VMA(1), (const char *)VMA(2), VM_GAME );
1843 return 0;
1844
1845 case G_CVAR_VARIABLE_INTEGER_VALUE:
1846 return Cvar_VariableIntegerValue( (const char *)VMA(1) );
1847
1848 case G_CVAR_VARIABLE_STRING_BUFFER:
1849 Cvar_VariableStringBuffer( (const char *)VMA(1), (char *)VMA(2), args[3] );
1850 return 0;
1851
1852 case G_ARGC:
1853 return Cmd_Argc();
1854
1855 case G_ARGV:
1856 Cmd_ArgvBuffer( args[1], (char *)VMA(2), args[3] );
1857 return 0;
1858
1859 case G_SEND_CONSOLE_COMMAND:
1860 Cbuf_ExecuteText( args[1], (const char *)VMA(2) );
1861 return 0;
1862
1863 case G_FS_FOPEN_FILE:
1864 return FS_FOpenFileByMode( (const char *)VMA(1), (int *)VMA(2), (fsMode_t)args[3] );
1865
1866 case G_FS_READ:
1867 FS_Read( VMA(1), args[2], args[3] );
1868 return 0;
1869
1870 case G_FS_WRITE:
1871 FS_Write( VMA(1), args[2], args[3] );
1872 return 0;
1873
1874 case G_FS_FCLOSE_FILE:
1875 FS_FCloseFile( args[1] );
1876 return 0;
1877
1878 case G_FS_GETFILELIST:
1879 return FS_GetFileList( (const char *)VMA(1), (const char *)VMA(2), (char *)VMA(3), args[4] );
1880
1881 case G_LOCATE_GAME_DATA:
1882 SV_LocateGameData( (sharedEntity_t *)VMA(1), args[2], args[3], (struct playerState_s *)VMA(4), args[5] );
1883 return 0;
1884
1885 case G_DROP_CLIENT:
1886 SV_GameDropClient( args[1], (const char *)VMA(2) );
1887 return 0;
1888
1889 case G_SEND_SERVER_COMMAND:
1890 SV_GameSendServerCommand( args[1], (const char *)VMA(2) );
1891 return 0;
1892
1893 case G_LINKENTITY:
1894 SV_LinkEntity( (sharedEntity_t *)VMA(1) );
1895 return 0;
1896
1897 case G_UNLINKENTITY:
1898 SV_UnlinkEntity( (sharedEntity_t *)VMA(1) );
1899 return 0;
1900
1901 case G_ENTITIES_IN_BOX:
1902 return SV_AreaEntities( (const float *)VMA(1), (const float *)VMA(2), (int *)VMA(3), args[4] );
1903
1904 case G_ENTITY_CONTACT:
1905 return SV_EntityContact( (const float *)VMA(1), (const float *)VMA(2), (const sharedEntity_t *)VMA(3), /*int capsule*/ qfalse );
1906
1907 case G_ENTITY_CONTACTCAPSULE:
1908 return SV_EntityContact( (const float *)VMA(1), (const float *)VMA(2), (const sharedEntity_t *)VMA(3), /*int capsule*/ qtrue );
1909
1910 case G_TRACE:
1911 SV_Trace( (trace_t *)VMA(1), (const float *)VMA(2), (const float *)VMA(3), (const float *)VMA(4), (const float *)VMA(5), args[6], args[7], /*int capsule*/ qfalse, /*args[8]*/0, args[9] );
1912 return 0;
1913 case G_G2TRACE:
1914 SV_Trace( (trace_t *)VMA(1), (const float *)VMA(2), (const float *)VMA(3), (const float *)VMA(4), (const float *)VMA(5), args[6], args[7], /*int capsule*/ qfalse, args[8], args[9] );
1915 return 0;
1916 case G_TRACECAPSULE:
1917 SV_Trace( (trace_t *)VMA(1), (const float *)VMA(2), (const float *)VMA(3), (const float *)VMA(4), (const float *)VMA(5), args[6], args[7], /*int capsule*/ qtrue, args[8], args[9] );
1918 return 0;
1919 case G_POINT_CONTENTS:
1920 return SV_PointContents( (const float *)VMA(1), args[2] );
1921 case G_SET_SERVER_CULL:
1922 SV_SetServerCull( VMF( 1 ) );
1923 return 0;
1924 case G_SET_BRUSH_MODEL:
1925 SV_SetBrushModel( (sharedEntity_t *)VMA(1), (const char *)VMA(2) );
1926 return 0;
1927 case G_IN_PVS:
1928 return SV_inPVS( (const float *)VMA(1), (const float *)VMA(2) );
1929 case G_IN_PVS_IGNORE_PORTALS:
1930 return SV_inPVSIgnorePortals( (const float *)VMA(1), (const float *)VMA(2) );
1931
1932 case G_SET_CONFIGSTRING:
1933 SV_SetConfigstring( args[1], (const char *)VMA(2) );
1934 return 0;
1935 case G_GET_CONFIGSTRING:
1936 SV_GetConfigstring( args[1], (char *)VMA(2), args[3] );
1937 return 0;
1938 case G_SET_USERINFO:
1939 SV_SetUserinfo( args[1], (const char *)VMA(2) );
1940 return 0;
1941 case G_GET_USERINFO:
1942 SV_GetUserinfo( args[1], (char *)VMA(2), args[3] );
1943 return 0;
1944 case G_GET_SERVERINFO:
1945 SV_GetServerinfo( (char *)VMA(1), args[2] );
1946 return 0;
1947 case G_ADJUST_AREA_PORTAL_STATE:
1948 SV_AdjustAreaPortalState( (sharedEntity_t *)VMA(1), (qboolean)args[2] );
1949 return 0;
1950 case G_AREAS_CONNECTED:
1951 return CM_AreasConnected( args[1], args[2] );
1952
1953 case G_BOT_ALLOCATE_CLIENT:
1954 return SV_BotAllocateClient();
1955 case G_BOT_FREE_CLIENT:
1956 SV_BotFreeClient( args[1] );
1957 return 0;
1958
1959 case G_GET_USERCMD:
1960 SV_GetUsercmd( args[1], (struct usercmd_s *)VMA(2) );
1961 return 0;
1962
1963 case G_SIEGEPERSSET:
1964 SV_SiegePersSet( (siegePers_t *)VMA( 1 ) );
1965 return 0;
1966
1967 case G_SIEGEPERSGET:
1968 SV_SiegePersGet( (siegePers_t *)VMA( 1 ) );
1969 return 0;
1970
1971 //rwwRMG - see below
1972 /*
1973 case G_GET_ENTITY_TOKEN:
1974 {
1975 const char *s;
1976
1977 s = COM_Parse( (const char **) &sv.entityParsePoint );
1978 Q_strncpyz( (char *)VMA(1), s, args[2] );
1979 if ( !sv.entityParsePoint && !s[0] ) {
1980 return qfalse;
1981 } else {
1982 return qtrue;
1983 }
1984 }
1985 */
1986
1987 /*
1988 case G_BOT_GET_MEMORY:
1989 void *ptr;
1990 ptr = Bot_GetMemoryGame(args[1]);
1991 return (int)ptr;
1992 case G_BOT_FREE_MEMORY:
1993 Bot_FreeMemoryGame((void *)VMA(1));
1994 return 0;
1995 */
1996 case G_DEBUG_POLYGON_CREATE:
1997 return BotImport_DebugPolygonCreate( args[1], args[2], (float (*)[3])VMA(3) );
1998 case G_DEBUG_POLYGON_DELETE:
1999 BotImport_DebugPolygonDelete( args[1] );
2000 return 0;
2001 case G_REAL_TIME:
2002 return Com_RealTime( (struct qtime_s *)VMA(1) );
2003 case G_SNAPVECTOR:
2004 Sys_SnapVector( (float *)VMA(1) );
2005 return 0;
2006
2007 case SP_GETSTRINGTEXTSTRING:
2008 return qfalse;
2009 break;
2010
2011 case G_ROFF_CLEAN:
2012 return SV_ROFF_Clean();
2013
2014 case G_ROFF_UPDATE_ENTITIES:
2015 SV_ROFF_UpdateEntities();
2016 return 0;
2017
2018 case G_ROFF_CACHE:
2019 return SV_ROFF_Cache( (char *)VMA(1) );
2020
2021 case G_ROFF_PLAY:
2022 return SV_ROFF_Play( args[1], args[2], (qboolean)args[3] );
2023
2024 case G_ROFF_PURGE_ENT:
2025 return SV_ROFF_Purge_Ent( args[1] );
2026
2027 //rww - dynamic vm memory allocation!
2028 case G_TRUEMALLOC:
2029 VM_Shifted_Alloc((void **)VMA(1), args[2]);
2030 return 0;
2031 case G_TRUEFREE:
2032 VM_Shifted_Free((void **)VMA(1));
2033 return 0;
2034
2035 //rww - icarus traps
2036 case G_ICARUS_RUNSCRIPT:
2037 return ICARUS_RunScript(ConvertedEntity((sharedEntity_t *)VMA(1)), (const char *)VMA(2));
2038
2039 case G_ICARUS_REGISTERSCRIPT:
2040 return ICARUS_RegisterScript((const char *)VMA(1), (qboolean)args[2]);
2041
2042 case G_ICARUS_INIT:
2043 ICARUS_Init();
2044 return 0;
2045
2046 case G_ICARUS_VALIDENT:
2047 return ICARUS_ValidEnt(ConvertedEntity((sharedEntity_t *)VMA(1)));
2048
2049 case G_ICARUS_ISINITIALIZED:
2050 return ICARUS_IsInitialized( args[1] );
2051
2052 case G_ICARUS_MAINTAINTASKMANAGER:
2053 return ICARUS_MaintainTaskManager( args[1] );
2054
2055 case G_ICARUS_ISRUNNING:
2056 return ICARUS_IsRunning( args[1] );
2057
2058 case G_ICARUS_TASKIDPENDING:
2059 return Q3_TaskIDPending((sharedEntity_t *)VMA(1), (taskID_t)args[2]);
2060
2061 case G_ICARUS_INITENT:
2062 ICARUS_InitEnt(ConvertedEntity((sharedEntity_t *)VMA(1)));
2063 return 0;
2064
2065 case G_ICARUS_FREEENT:
2066 ICARUS_FreeEnt(ConvertedEntity((sharedEntity_t *)VMA(1)));
2067 return 0;
2068
2069 case G_ICARUS_ASSOCIATEENT:
2070 ICARUS_AssociateEnt(ConvertedEntity((sharedEntity_t *)VMA(1)));
2071 return 0;
2072
2073 case G_ICARUS_SHUTDOWN:
2074 ICARUS_Shutdown();
2075 return 0;
2076
2077 case G_ICARUS_TASKIDSET:
2078 //rww - note that we are passing in the true entity here.
2079 //This is because we allow modification of certain non-pointer values,
2080 //which is valid.
2081 Q3_TaskIDSet((sharedEntity_t *)VMA(1), (taskID_t)args[2], args[3]);
2082 return 0;
2083
2084 case G_ICARUS_TASKIDCOMPLETE:
2085 //same as above.
2086 Q3_TaskIDComplete((sharedEntity_t *)VMA(1), (taskID_t)args[2]);
2087 return 0;
2088
2089 case G_ICARUS_SETVAR:
2090 Q3_SetVar(args[1], args[2], (const char *)VMA(3), (const char *)VMA(4));
2091 return 0;
2092
2093 case G_ICARUS_VARIABLEDECLARED:
2094 return Q3_VariableDeclared((const char *)VMA(1));
2095
2096 case G_ICARUS_GETFLOATVARIABLE:
2097 return Q3_GetFloatVariable((const char *)VMA(1), (float *)VMA(2));
2098
2099 case G_ICARUS_GETSTRINGVARIABLE:
2100 {
2101 const char *rec = (const char *)VMA(2);
2102 return Q3_GetStringVariable((const char *)VMA(1), (const char **)&rec);
2103 }
2104
2105 case G_ICARUS_GETVECTORVARIABLE:
2106 return Q3_GetVectorVariable((const char *)VMA(1), (float *)VMA(2));
2107
2108
2109 //rww - BEGIN NPC NAV TRAPS
2110 case G_NAV_INIT:
2111 navigator.Init();
2112 return 0;
2113 case G_NAV_FREE:
2114 navigator.Free();
2115 return 0;
2116 case G_NAV_LOAD:
2117 return navigator.Load((const char *)VMA(1), args[2]);
2118 case G_NAV_SAVE:
2119 return navigator.Save((const char *)VMA(1), args[2]);
2120 case G_NAV_ADDRAWPOINT:
2121 return navigator.AddRawPoint((float *)VMA(1), args[2], args[3]);
2122 case G_NAV_CALCULATEPATHS:
2123 navigator.CalculatePaths((qboolean)args[1]);
2124 return 0;
2125 case G_NAV_HARDCONNECT:
2126 navigator.HardConnect(args[1], args[2]);
2127 return 0;
2128 case G_NAV_SHOWNODES:
2129 navigator.ShowNodes();
2130 return 0;
2131 case G_NAV_SHOWEDGES:
2132 navigator.ShowEdges();
2133 return 0;
2134 case G_NAV_SHOWPATH:
2135 navigator.ShowPath(args[1], args[2]);
2136 return 0;
2137 case G_NAV_GETNEARESTNODE:
2138 return navigator.GetNearestNode((sharedEntity_t *)VMA(1), args[2], args[3], args[4]);
2139 case G_NAV_GETBESTNODE:
2140 return navigator.GetBestNode(args[1], args[2], args[3]);
2141 case G_NAV_GETNODEPOSITION:
2142 return navigator.GetNodePosition(args[1], (float *)VMA(2));
2143 case G_NAV_GETNODENUMEDGES:
2144 return navigator.GetNodeNumEdges(args[1]);
2145 case G_NAV_GETNODEEDGE:
2146 return navigator.GetNodeEdge(args[1], args[2]);
2147 case G_NAV_GETNUMNODES:
2148 return navigator.GetNumNodes();
2149 case G_NAV_CONNECTED:
2150 return navigator.Connected(args[1], args[2]);
2151 case G_NAV_GETPATHCOST:
2152 return navigator.GetPathCost(args[1], args[2]);
2153 case G_NAV_GETEDGECOST:
2154 return navigator.GetEdgeCost(args[1], args[2]);
2155 case G_NAV_GETPROJECTEDNODE:
2156 return navigator.GetProjectedNode((float *)VMA(1), args[2]);
2157 case G_NAV_CHECKFAILEDNODES:
2158 navigator.CheckFailedNodes((sharedEntity_t *)VMA(1));
2159 return 0;
2160 case G_NAV_ADDFAILEDNODE:
2161 navigator.AddFailedNode((sharedEntity_t *)VMA(1), args[2]);
2162 return 0;
2163 case G_NAV_NODEFAILED:
2164 return navigator.NodeFailed((sharedEntity_t *)VMA(1), args[2]);
2165 case G_NAV_NODESARENEIGHBORS:
2166 return navigator.NodesAreNeighbors(args[1], args[2]);
2167 case G_NAV_CLEARFAILEDEDGE:
2168 navigator.ClearFailedEdge((failedEdge_t *)VMA(1));
2169 return 0;
2170 case G_NAV_CLEARALLFAILEDEDGES:
2171 navigator.ClearAllFailedEdges();
2172 return 0;
2173 case G_NAV_EDGEFAILED:
2174 return navigator.EdgeFailed(args[1], args[2]);
2175 case G_NAV_ADDFAILEDEDGE:
2176 navigator.AddFailedEdge(args[1], args[2], args[3]);
2177 return 0;
2178 case G_NAV_CHECKFAILEDEDGE:
2179 return navigator.CheckFailedEdge((failedEdge_t *)VMA(1));
2180 case G_NAV_CHECKALLFAILEDEDGES:
2181 navigator.CheckAllFailedEdges();
2182 return 0;
2183 case G_NAV_ROUTEBLOCKED:
2184 return navigator.RouteBlocked(args[1], args[2], args[3], args[4]);
2185 case G_NAV_GETBESTNODEALTROUTE:
2186 return navigator.GetBestNodeAltRoute(args[1], args[2], (int *)VMA(3), args[4]);
2187 case G_NAV_GETBESTNODEALT2:
2188 return navigator.GetBestNodeAltRoute(args[1], args[2], args[3]);
2189 case G_NAV_GETBESTPATHBETWEENENTS:
2190 return navigator.GetBestPathBetweenEnts((sharedEntity_t *)VMA(1), (sharedEntity_t *)VMA(2), args[3]);
2191 case G_NAV_GETNODERADIUS:
2192 return navigator.GetNodeRadius(args[1]);
2193 case G_NAV_CHECKBLOCKEDEDGES:
2194 navigator.CheckBlockedEdges();
2195 return 0;
2196 case G_NAV_CLEARCHECKEDNODES:
2197 navigator.ClearCheckedNodes();
2198 return 0;
2199 case G_NAV_CHECKEDNODE:
2200 return navigator.CheckedNode(args[1], args[2]);
2201 case G_NAV_SETCHECKEDNODE:
2202 navigator.SetCheckedNode(args[1], args[2], args[3]);
2203 return 0;
2204 case G_NAV_FLAGALLNODES:
2205 navigator.FlagAllNodes(args[1]);
2206 return 0;
2207 case G_NAV_GETPATHSCALCULATED:
2208 return navigator.pathsCalculated;
2209 case G_NAV_SETPATHSCALCULATED:
2210 navigator.pathsCalculated = (qboolean)args[1];
2211 return 0;
2212 //rww - END NPC NAV TRAPS
2213
2214 case G_SET_SHARED_BUFFER:
2215 SV_RegisterSharedMemory( (char *)VMA(1) );
2216 return 0;
2217 //====================================
2218
2219 case BOTLIB_SETUP:
2220 return SV_BotLibSetup();
2221 case BOTLIB_SHUTDOWN:
2222 return SV_BotLibShutdown();
2223 case BOTLIB_LIBVAR_SET:
2224 return botlib_export->BotLibVarSet( (char *)VMA(1), (char *)VMA(2) );
2225 case BOTLIB_LIBVAR_GET:
2226 return botlib_export->BotLibVarGet( (char *)VMA(1), (char *)VMA(2), args[3] );
2227
2228 case BOTLIB_PC_ADD_GLOBAL_DEFINE:
2229 return botlib_export->PC_AddGlobalDefine( (char *)VMA(1) );
2230 case BOTLIB_PC_LOAD_SOURCE:
2231 return botlib_export->PC_LoadSourceHandle( (const char *)VMA(1) );
2232 case BOTLIB_PC_FREE_SOURCE:
2233 return botlib_export->PC_FreeSourceHandle( args[1] );
2234 case BOTLIB_PC_READ_TOKEN:
2235 return botlib_export->PC_ReadTokenHandle( args[1], (struct pc_token_s *)VMA(2) );
2236 case BOTLIB_PC_SOURCE_FILE_AND_LINE:
2237 return botlib_export->PC_SourceFileAndLine( args[1], (char *)VMA(2), (int *)VMA(3) );
2238
2239 case BOTLIB_START_FRAME:
2240 return botlib_export->BotLibStartFrame( VMF(1) );
2241 case BOTLIB_LOAD_MAP:
2242 return botlib_export->BotLibLoadMap( (const char *)VMA(1) );
2243 case BOTLIB_UPDATENTITY:
2244 return botlib_export->BotLibUpdateEntity( args[1], (struct bot_entitystate_s *)VMA(2) );
2245 case BOTLIB_TEST:
2246 return botlib_export->Test( args[1], (char *)VMA(2), (float *)VMA(3), (float *)VMA(4) );
2247
2248 case BOTLIB_GET_SNAPSHOT_ENTITY:
2249 return SV_BotGetSnapshotEntity( args[1], args[2] );
2250 case BOTLIB_GET_CONSOLE_MESSAGE:
2251 return SV_BotGetConsoleMessage( args[1], (char *)VMA(2), args[3] );
2252 case BOTLIB_USER_COMMAND:
2253 SV_ClientThink( &svs.clients[args[1]], (struct usercmd_s *)VMA(2) );
2254 return 0;
2255
2256 case BOTLIB_AAS_BBOX_AREAS:
2257 return botlib_export->aas.AAS_BBoxAreas( (float *)VMA(1), (float *)VMA(2), (int *)VMA(3), args[4] );
2258 case BOTLIB_AAS_AREA_INFO:
2259 return botlib_export->aas.AAS_AreaInfo( args[1], (struct aas_areainfo_s *)VMA(2) );
2260 case BOTLIB_AAS_ALTERNATIVE_ROUTE_GOAL:
2261 return botlib_export->aas.AAS_AlternativeRouteGoals( (float *)VMA(1), args[2], (float *)VMA(3), args[4], args[5], (struct aas_altroutegoal_s *)VMA(6), args[7], args[8] );
2262 case BOTLIB_AAS_ENTITY_INFO:
2263 botlib_export->aas.AAS_EntityInfo( args[1], (struct aas_entityinfo_s *)VMA(2) );
2264 return 0;
2265
2266 case BOTLIB_AAS_INITIALIZED:
2267 return botlib_export->aas.AAS_Initialized();
2268 case BOTLIB_AAS_PRESENCE_TYPE_BOUNDING_BOX:
2269 botlib_export->aas.AAS_PresenceTypeBoundingBox( args[1], (float *)VMA(2), (float *)VMA(3) );
2270 return 0;
2271 case BOTLIB_AAS_TIME:
2272 return FloatAsInt( botlib_export->aas.AAS_Time() );
2273
2274 case BOTLIB_AAS_POINT_AREA_NUM:
2275 return botlib_export->aas.AAS_PointAreaNum( (float *)VMA(1) );
2276 case BOTLIB_AAS_POINT_REACHABILITY_AREA_INDEX:
2277 return botlib_export->aas.AAS_PointReachabilityAreaIndex( (float *)VMA(1) );
2278 case BOTLIB_AAS_TRACE_AREAS:
2279 return botlib_export->aas.AAS_TraceAreas( (float *)VMA(1), (float *)VMA(2), (int *)VMA(3), (float (*)[3])VMA(4), args[5] );
2280
2281 case BOTLIB_AAS_POINT_CONTENTS:
2282 return botlib_export->aas.AAS_PointContents( (float *)VMA(1) );
2283 case BOTLIB_AAS_NEXT_BSP_ENTITY:
2284 return botlib_export->aas.AAS_NextBSPEntity( args[1] );
2285 case BOTLIB_AAS_VALUE_FOR_BSP_EPAIR_KEY:
2286 return botlib_export->aas.AAS_ValueForBSPEpairKey( args[1], (char *)VMA(2), (char *)VMA(3), args[4] );
2287 case BOTLIB_AAS_VECTOR_FOR_BSP_EPAIR_KEY:
2288 return botlib_export->aas.AAS_VectorForBSPEpairKey( args[1], (char *)VMA(2), (float *)VMA(3) );
2289 case BOTLIB_AAS_FLOAT_FOR_BSP_EPAIR_KEY:
2290 return botlib_export->aas.AAS_FloatForBSPEpairKey( args[1], (char *)VMA(2), (float *)VMA(3) );
2291 case BOTLIB_AAS_INT_FOR_BSP_EPAIR_KEY:
2292 return botlib_export->aas.AAS_IntForBSPEpairKey( args[1], (char *)VMA(2), (int *)VMA(3) );
2293
2294 case BOTLIB_AAS_AREA_REACHABILITY:
2295 return botlib_export->aas.AAS_AreaReachability( args[1] );
2296
2297 case BOTLIB_AAS_AREA_TRAVEL_TIME_TO_GOAL_AREA:
2298 return botlib_export->aas.AAS_AreaTravelTimeToGoalArea( args[1], (float *)VMA(2), args[3], args[4] );
2299 case BOTLIB_AAS_ENABLE_ROUTING_AREA:
2300 return botlib_export->aas.AAS_EnableRoutingArea( args[1], args[2] );
2301 case BOTLIB_AAS_PREDICT_ROUTE:
2302 return botlib_export->aas.AAS_PredictRoute( (struct aas_predictroute_s *)VMA(1), args[2], (float *)VMA(3), args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11] );
2303
2304 case BOTLIB_AAS_SWIMMING:
2305 return botlib_export->aas.AAS_Swimming( (float *)VMA(1) );
2306 case BOTLIB_AAS_PREDICT_CLIENT_MOVEMENT:
2307 return botlib_export->aas.AAS_PredictClientMovement( (struct aas_clientmove_s *)VMA(1), args[2], (float *)VMA(3), args[4], args[5],
2308 (float *)VMA(6), (float *)VMA(7), args[8], args[9], VMF(10), args[11], args[12], args[13] );
2309
2310 case BOTLIB_EA_SAY:
2311 botlib_export->ea.EA_Say( args[1], (char *)VMA(2) );
2312 return 0;
2313 case BOTLIB_EA_SAY_TEAM:
2314 botlib_export->ea.EA_SayTeam( args[1], (char *)VMA(2) );
2315 return 0;
2316 case BOTLIB_EA_COMMAND:
2317 botlib_export->ea.EA_Command( args[1], (char *)VMA(2) );
2318 return 0;
2319
2320 case BOTLIB_EA_ACTION:
2321 botlib_export->ea.EA_Action( args[1], args[2] );
2322 break;
2323 case BOTLIB_EA_GESTURE:
2324 botlib_export->ea.EA_Gesture( args[1] );
2325 return 0;
2326 case BOTLIB_EA_TALK:
2327 botlib_export->ea.EA_Talk( args[1] );
2328 return 0;
2329 case BOTLIB_EA_ATTACK:
2330 botlib_export->ea.EA_Attack( args[1] );
2331 return 0;
2332 case BOTLIB_EA_ALT_ATTACK:
2333 botlib_export->ea.EA_Alt_Attack( args[1] );
2334 return 0;
2335 case BOTLIB_EA_FORCEPOWER:
2336 botlib_export->ea.EA_ForcePower( args[1] );
2337 return 0;
2338 case BOTLIB_EA_USE:
2339 botlib_export->ea.EA_Use( args[1] );
2340 return 0;
2341 case BOTLIB_EA_RESPAWN:
2342 botlib_export->ea.EA_Respawn( args[1] );
2343 return 0;
2344 case BOTLIB_EA_CROUCH:
2345 botlib_export->ea.EA_Crouch( args[1] );
2346 return 0;
2347 case BOTLIB_EA_MOVE_UP:
2348 botlib_export->ea.EA_MoveUp( args[1] );
2349 return 0;
2350 case BOTLIB_EA_MOVE_DOWN:
2351 botlib_export->ea.EA_MoveDown( args[1] );
2352 return 0;
2353 case BOTLIB_EA_MOVE_FORWARD:
2354 botlib_export->ea.EA_MoveForward( args[1] );
2355 return 0;
2356 case BOTLIB_EA_MOVE_BACK:
2357 botlib_export->ea.EA_MoveBack( args[1] );
2358 return 0;
2359 case BOTLIB_EA_MOVE_LEFT:
2360 botlib_export->ea.EA_MoveLeft( args[1] );
2361 return 0;
2362 case BOTLIB_EA_MOVE_RIGHT:
2363 botlib_export->ea.EA_MoveRight( args[1] );
2364 return 0;
2365
2366 case BOTLIB_EA_SELECT_WEAPON:
2367 botlib_export->ea.EA_SelectWeapon( args[1], args[2] );
2368 return 0;
2369 case BOTLIB_EA_JUMP:
2370 botlib_export->ea.EA_Jump( args[1] );
2371 return 0;
2372 case BOTLIB_EA_DELAYED_JUMP:
2373 botlib_export->ea.EA_DelayedJump( args[1] );
2374 return 0;
2375 case BOTLIB_EA_MOVE:
2376 botlib_export->ea.EA_Move( args[1], (float *)VMA(2), VMF(3) );
2377 return 0;
2378 case BOTLIB_EA_VIEW:
2379 botlib_export->ea.EA_View( args[1], (float *)VMA(2) );
2380 return 0;
2381
2382 case BOTLIB_EA_END_REGULAR:
2383 botlib_export->ea.EA_EndRegular( args[1], VMF(2) );
2384 return 0;
2385 case BOTLIB_EA_GET_INPUT:
2386 botlib_export->ea.EA_GetInput( args[1], VMF(2), (struct bot_input_s *)VMA(3) );
2387 return 0;
2388 case BOTLIB_EA_RESET_INPUT:
2389 botlib_export->ea.EA_ResetInput( args[1] );
2390 return 0;
2391
2392 case BOTLIB_AI_LOAD_CHARACTER:
2393 return botlib_export->ai.BotLoadCharacter( (char *)VMA(1), VMF(2) );
2394 case BOTLIB_AI_FREE_CHARACTER:
2395 botlib_export->ai.BotFreeCharacter( args[1] );
2396 return 0;
2397 case BOTLIB_AI_CHARACTERISTIC_FLOAT:
2398 return FloatAsInt( botlib_export->ai.Characteristic_Float( args[1], args[2] ) );
2399 case BOTLIB_AI_CHARACTERISTIC_BFLOAT:
2400 return FloatAsInt( botlib_export->ai.Characteristic_BFloat( args[1], args[2], VMF(3), VMF(4) ) );
2401 case BOTLIB_AI_CHARACTERISTIC_INTEGER:
2402 return botlib_export->ai.Characteristic_Integer( args[1], args[2] );
2403 case BOTLIB_AI_CHARACTERISTIC_BINTEGER:
2404 return botlib_export->ai.Characteristic_BInteger( args[1], args[2], args[3], args[4] );
2405 case BOTLIB_AI_CHARACTERISTIC_STRING:
2406 botlib_export->ai.Characteristic_String( args[1], args[2], (char *)VMA(3), args[4] );
2407 return 0;
2408
2409 case BOTLIB_AI_ALLOC_CHAT_STATE:
2410 return botlib_export->ai.BotAllocChatState();
2411 case BOTLIB_AI_FREE_CHAT_STATE:
2412 botlib_export->ai.BotFreeChatState( args[1] );
2413 return 0;
2414 case BOTLIB_AI_QUEUE_CONSOLE_MESSAGE:
2415 botlib_export->ai.BotQueueConsoleMessage( args[1], args[2], (char *)VMA(3) );
2416 return 0;
2417 case BOTLIB_AI_REMOVE_CONSOLE_MESSAGE:
2418 botlib_export->ai.BotRemoveConsoleMessage( args[1], args[2] );
2419 return 0;
2420 case BOTLIB_AI_NEXT_CONSOLE_MESSAGE:
2421 return botlib_export->ai.BotNextConsoleMessage( args[1], (struct bot_consolemessage_s *)VMA(2) );
2422 case BOTLIB_AI_NUM_CONSOLE_MESSAGE:
2423 return botlib_export->ai.BotNumConsoleMessages( args[1] );
2424 case BOTLIB_AI_INITIAL_CHAT:
2425 botlib_export->ai.BotInitialChat( args[1], (char *)VMA(2), args[3], (char *)VMA(4), (char *)VMA(5), (char *)VMA(6), (char *)VMA(7), (char *)VMA(8), (char *)VMA(9), (char *)VMA(10), (char *)VMA(11) );
2426 return 0;
2427 case BOTLIB_AI_NUM_INITIAL_CHATS:
2428 return botlib_export->ai.BotNumInitialChats( args[1], (char *)VMA(2) );
2429 case BOTLIB_AI_REPLY_CHAT:
2430 return botlib_export->ai.BotReplyChat( args[1], (char *)VMA(2), args[3], args[4], (char *)VMA(5), (char *)VMA(6), (char *)VMA(7), (char *)VMA(8), (char *)VMA(9), (char *)VMA(10), (char *)VMA(11), (char *)VMA(12) );
2431 case BOTLIB_AI_CHAT_LENGTH:
2432 return botlib_export->ai.BotChatLength( args[1] );
2433 case BOTLIB_AI_ENTER_CHAT:
2434 botlib_export->ai.BotEnterChat( args[1], args[2], args[3] );
2435 return 0;
2436 case BOTLIB_AI_GET_CHAT_MESSAGE:
2437 botlib_export->ai.BotGetChatMessage( args[1], (char *)VMA(2), args[3] );
2438 return 0;
2439 case BOTLIB_AI_STRING_CONTAINS:
2440 return botlib_export->ai.StringContains( (char *)VMA(1), (char *)VMA(2), args[3] );
2441 case BOTLIB_AI_FIND_MATCH:
2442 return botlib_export->ai.BotFindMatch( (char *)VMA(1), (struct bot_match_s *)VMA(2), args[3] );
2443 case BOTLIB_AI_MATCH_VARIABLE:
2444 botlib_export->ai.BotMatchVariable( (struct bot_match_s *)VMA(1), args[2], (char *)VMA(3), args[4] );
2445 return 0;
2446 case BOTLIB_AI_UNIFY_WHITE_SPACES:
2447 botlib_export->ai.UnifyWhiteSpaces( (char *)VMA(1) );
2448 return 0;
2449 case BOTLIB_AI_REPLACE_SYNONYMS:
2450 botlib_export->ai.BotReplaceSynonyms( (char *)VMA(1), args[2] );
2451 return 0;
2452 case BOTLIB_AI_LOAD_CHAT_FILE:
2453 return botlib_export->ai.BotLoadChatFile( args[1], (char *)VMA(2), (char *)VMA(3) );
2454 case BOTLIB_AI_SET_CHAT_GENDER:
2455 botlib_export->ai.BotSetChatGender( args[1], args[2] );
2456 return 0;
2457 case BOTLIB_AI_SET_CHAT_NAME:
2458 botlib_export->ai.BotSetChatName( args[1], (char *)VMA(2), args[3] );
2459 return 0;
2460
2461 case BOTLIB_AI_RESET_GOAL_STATE:
2462 botlib_export->ai.BotResetGoalState( args[1] );
2463 return 0;
2464 case BOTLIB_AI_RESET_AVOID_GOALS:
2465 botlib_export->ai.BotResetAvoidGoals( args[1] );
2466 return 0;
2467 case BOTLIB_AI_REMOVE_FROM_AVOID_GOALS:
2468 botlib_export->ai.BotRemoveFromAvoidGoals( args[1], args[2] );
2469 return 0;
2470 case BOTLIB_AI_PUSH_GOAL:
2471 botlib_export->ai.BotPushGoal( args[1], (struct bot_goal_s *)VMA(2) );
2472 return 0;
2473 case BOTLIB_AI_POP_GOAL:
2474 botlib_export->ai.BotPopGoal( args[1] );
2475 return 0;
2476 case BOTLIB_AI_EMPTY_GOAL_STACK:
2477 botlib_export->ai.BotEmptyGoalStack( args[1] );
2478 return 0;
2479 case BOTLIB_AI_DUMP_AVOID_GOALS:
2480 botlib_export->ai.BotDumpAvoidGoals( args[1] );
2481 return 0;
2482 case BOTLIB_AI_DUMP_GOAL_STACK:
2483 botlib_export->ai.BotDumpGoalStack( args[1] );
2484 return 0;
2485 case BOTLIB_AI_GOAL_NAME:
2486 botlib_export->ai.BotGoalName( args[1], (char *)VMA(2), args[3] );
2487 return 0;
2488 case BOTLIB_AI_GET_TOP_GOAL:
2489 return botlib_export->ai.BotGetTopGoal( args[1], (struct bot_goal_s *)VMA(2) );
2490 case BOTLIB_AI_GET_SECOND_GOAL:
2491 return botlib_export->ai.BotGetSecondGoal( args[1], (struct bot_goal_s *)VMA(2) );
2492 case BOTLIB_AI_CHOOSE_LTG_ITEM:
2493 return botlib_export->ai.BotChooseLTGItem( args[1], (float *)VMA(2), (int *)VMA(3), args[4] );
2494 case BOTLIB_AI_CHOOSE_NBG_ITEM:
2495 return botlib_export->ai.BotChooseNBGItem( args[1], (float *)VMA(2), (int *)VMA(3), args[4], (struct bot_goal_s *)VMA(5), VMF(6) );
2496 case BOTLIB_AI_TOUCHING_GOAL:
2497 return botlib_export->ai.BotTouchingGoal( (float *)VMA(1), (struct bot_goal_s *)VMA(2) );
2498 case BOTLIB_AI_ITEM_GOAL_IN_VIS_BUT_NOT_VISIBLE:
2499 return botlib_export->ai.BotItemGoalInVisButNotVisible( args[1], (float *)VMA(2), (float *)VMA(3), (struct bot_goal_s *)VMA(4) );
2500 case BOTLIB_AI_GET_LEVEL_ITEM_GOAL:
2501 return botlib_export->ai.BotGetLevelItemGoal( args[1], (char *)VMA(2), (struct bot_goal_s *)VMA(3) );
2502 case BOTLIB_AI_GET_NEXT_CAMP_SPOT_GOAL:
2503 return botlib_export->ai.BotGetNextCampSpotGoal( args[1], (struct bot_goal_s *)VMA(2) );
2504 case BOTLIB_AI_GET_MAP_LOCATION_GOAL:
2505 return botlib_export->ai.BotGetMapLocationGoal( (char *)VMA(1), (struct bot_goal_s *)VMA(2) );
2506 case BOTLIB_AI_AVOID_GOAL_TIME:
2507 return FloatAsInt( botlib_export->ai.BotAvoidGoalTime( args[1], args[2] ) );
2508 case BOTLIB_AI_SET_AVOID_GOAL_TIME:
2509 botlib_export->ai.BotSetAvoidGoalTime( args[1], args[2], VMF(3));
2510 return 0;
2511 case BOTLIB_AI_INIT_LEVEL_ITEMS:
2512 botlib_export->ai.BotInitLevelItems();
2513 return 0;
2514 case BOTLIB_AI_UPDATE_ENTITY_ITEMS:
2515 botlib_export->ai.BotUpdateEntityItems();
2516 return 0;
2517 case BOTLIB_AI_LOAD_ITEM_WEIGHTS:
2518 return botlib_export->ai.BotLoadItemWeights( args[1], (char *)VMA(2) );
2519 case BOTLIB_AI_FREE_ITEM_WEIGHTS:
2520 botlib_export->ai.BotFreeItemWeights( args[1] );
2521 return 0;
2522 case BOTLIB_AI_INTERBREED_GOAL_FUZZY_LOGIC:
2523 botlib_export->ai.BotInterbreedGoalFuzzyLogic( args[1], args[2], args[3] );
2524 return 0;
2525 case BOTLIB_AI_SAVE_GOAL_FUZZY_LOGIC:
2526 botlib_export->ai.BotSaveGoalFuzzyLogic( args[1], (char *)VMA(2) );
2527 return 0;
2528 case BOTLIB_AI_MUTATE_GOAL_FUZZY_LOGIC:
2529 botlib_export->ai.BotMutateGoalFuzzyLogic( args[1], VMF(2) );
2530 return 0;
2531 case BOTLIB_AI_ALLOC_GOAL_STATE:
2532 return botlib_export->ai.BotAllocGoalState( args[1] );
2533 case BOTLIB_AI_FREE_GOAL_STATE:
2534 botlib_export->ai.BotFreeGoalState( args[1] );
2535 return 0;
2536
2537 case BOTLIB_AI_RESET_MOVE_STATE:
2538 botlib_export->ai.BotResetMoveState( args[1] );
2539 return 0;
2540 case BOTLIB_AI_ADD_AVOID_SPOT:
2541 botlib_export->ai.BotAddAvoidSpot( args[1], (float *)VMA(2), VMF(3), args[4] );
2542 return 0;
2543 case BOTLIB_AI_MOVE_TO_GOAL:
2544 botlib_export->ai.BotMoveToGoal( (struct bot_moveresult_s *)VMA(1), args[2], (struct bot_goal_s *)VMA(3), args[4] );
2545 return 0;
2546 case BOTLIB_AI_MOVE_IN_DIRECTION:
2547 return botlib_export->ai.BotMoveInDirection( args[1], (float *)VMA(2), VMF(3), args[4] );
2548 case BOTLIB_AI_RESET_AVOID_REACH:
2549 botlib_export->ai.BotResetAvoidReach( args[1] );
2550 return 0;
2551 case BOTLIB_AI_RESET_LAST_AVOID_REACH:
2552 botlib_export->ai.BotResetLastAvoidReach( args[1] );
2553 return 0;
2554 case BOTLIB_AI_REACHABILITY_AREA:
2555 return botlib_export->ai.BotReachabilityArea( (float *)VMA(1), args[2] );
2556 case BOTLIB_AI_MOVEMENT_VIEW_TARGET:
2557 return botlib_export->ai.BotMovementViewTarget( args[1], (struct bot_goal_s *)VMA(2), args[3], VMF(4), (float *)VMA(5) );
2558 case BOTLIB_AI_PREDICT_VISIBLE_POSITION:
2559 return botlib_export->ai.BotPredictVisiblePosition( (float *)VMA(1), args[2], (struct bot_goal_s *)VMA(3), args[4], (float *)VMA(5) );
2560 case BOTLIB_AI_ALLOC_MOVE_STATE:
2561 return botlib_export->ai.BotAllocMoveState();
2562 case BOTLIB_AI_FREE_MOVE_STATE:
2563 botlib_export->ai.BotFreeMoveState( args[1] );
2564 return 0;
2565 case BOTLIB_AI_INIT_MOVE_STATE:
2566 botlib_export->ai.BotInitMoveState( args[1], (struct bot_initmove_s *)VMA(2) );
2567 return 0;
2568
2569 case BOTLIB_AI_CHOOSE_BEST_FIGHT_WEAPON:
2570 return botlib_export->ai.BotChooseBestFightWeapon( args[1], (int *)VMA(2) );
2571 case BOTLIB_AI_GET_WEAPON_INFO:
2572 botlib_export->ai.BotGetWeaponInfo( args[1], args[2], (struct weaponinfo_s *)VMA(3) );
2573 return 0;
2574 case BOTLIB_AI_LOAD_WEAPON_WEIGHTS:
2575 return botlib_export->ai.BotLoadWeaponWeights( args[1], (char *)VMA(2) );
2576 case BOTLIB_AI_ALLOC_WEAPON_STATE:
2577 return botlib_export->ai.BotAllocWeaponState();
2578 case BOTLIB_AI_FREE_WEAPON_STATE:
2579 botlib_export->ai.BotFreeWeaponState( args[1] );
2580 return 0;
2581 case BOTLIB_AI_RESET_WEAPON_STATE:
2582 botlib_export->ai.BotResetWeaponState( args[1] );
2583 return 0;
2584
2585 case BOTLIB_AI_GENETIC_PARENTS_AND_CHILD_SELECTION:
2586 return botlib_export->ai.GeneticParentsAndChildSelection(args[1], (float *)VMA(2), (int *)VMA(3), (int *)VMA(4), (int *)VMA(5));
2587
2588 case G_R_REGISTERSKIN:
2589 return re->RegisterServerSkin((const char *)VMA(1));
2590
2591 case G_G2_LISTBONES:
2592 SV_G2API_ListModelBones( VMA(1), args[2] );
2593 return 0;
2594
2595 case G_G2_LISTSURFACES:
2596 SV_G2API_ListModelSurfaces( VMA(1) );
2597 return 0;
2598
2599 case G_G2_HAVEWEGHOULMODELS:
2600 return SV_G2API_HaveWeGhoul2Models( VMA(1) );
2601
2602 case G_G2_SETMODELS:
2603 SV_G2API_SetGhoul2ModelIndexes( VMA(1),(qhandle_t *)VMA(2),(qhandle_t *)VMA(3));
2604 return 0;
2605
2606 case G_G2_GETBOLT:
2607 return SV_G2API_GetBoltMatrix(VMA(1), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
2608
2609 case G_G2_GETBOLT_NOREC:
2610 return SV_G2API_GetBoltMatrix_NoReconstruct(VMA(1), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
2611
2612 case G_G2_GETBOLT_NOREC_NOROT:
2613 return SV_G2API_GetBoltMatrix_NoRecNoRot(VMA(1), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
2614
2615 case G_G2_INITGHOUL2MODEL:
2616 #ifdef _FULL_G2_LEAK_CHECKING
2617 g_G2AllocServer = 1;
2618 #endif
2619 return SV_G2API_InitGhoul2Model((void **)VMA(1), (const char *)VMA(2), args[3], (qhandle_t) args[4],
2620 (qhandle_t) args[5], args[6], args[7]);
2621
2622 case G_G2_SETSKIN:
2623 return SV_G2API_SetSkin(VMA(1), args[2], args[3], args[4]);
2624
2625 case G_G2_SIZE:
2626 return SV_G2API_Ghoul2Size ( VMA(1) );
2627
2628 case G_G2_ADDBOLT:
2629 return SV_G2API_AddBolt(VMA(1), args[2], (const char *)VMA(3));
2630
2631 case G_G2_SETBOLTINFO:
2632 SV_G2API_SetBoltInfo(VMA(1), args[2], args[3]);
2633 return 0;
2634
2635 case G_G2_ANGLEOVERRIDE:
2636 return SV_G2API_SetBoneAngles(VMA(1), args[2], (const char *)VMA(3), (float *)VMA(4), args[5],
2637 (const Eorientations) args[6], (const Eorientations) args[7], (const Eorientations) args[8],
2638 (qhandle_t *)VMA(9), args[10], args[11] );
2639
2640 case G_G2_PLAYANIM:
2641 return SV_G2API_SetBoneAnim(VMA(1), args[2], (const char *)VMA(3), args[4], args[5],
2642 args[6], VMF(7), args[8], VMF(9), args[10]);
2643
2644 case G_G2_GETBONEANIM:
2645 return SV_G2API_GetBoneAnim(VMA(1), (const char*)VMA(2), args[3], (float *)VMA(4), (int *)VMA(5),
2646 (int *)VMA(6), (int *)VMA(7), (float *)VMA(8), (int *)VMA(9), args[10]);
2647
2648 case G_G2_GETGLANAME:
2649 SV_G2API_GetGLAName( VMA(1), args[2], (char *)VMA(3) );
2650 return 0;
2651
2652 case G_G2_COPYGHOUL2INSTANCE:
2653 return (int)SV_G2API_CopyGhoul2Instance(VMA(1), VMA(2), args[3]);
2654
2655 case G_G2_COPYSPECIFICGHOUL2MODEL:
2656 SV_G2API_CopySpecificGhoul2Model(VMA(1), args[2], VMA(3), args[4]);
2657 return 0;
2658
2659 case G_G2_DUPLICATEGHOUL2INSTANCE:
2660 #ifdef _FULL_G2_LEAK_CHECKING
2661 g_G2AllocServer = 1;
2662 #endif
2663 SV_G2API_DuplicateGhoul2Instance(VMA(1), (void **)VMA(2));
2664 return 0;
2665
2666 case G_G2_HASGHOUL2MODELONINDEX:
2667 return (int)SV_G2API_HasGhoul2ModelOnIndex((void **)VMA(1), args[2]);
2668
2669 case G_G2_REMOVEGHOUL2MODEL:
2670 #ifdef _FULL_G2_LEAK_CHECKING
2671 g_G2AllocServer = 1;
2672 #endif
2673 //return (int)G2API_RemoveGhoul2Model((CGhoul2Info_v **)args[1], args[2]);
2674 return (int)SV_G2API_RemoveGhoul2Model((void **)VMA(1), args[2]);
2675
2676 case G_G2_REMOVEGHOUL2MODELS:
2677 #ifdef _FULL_G2_LEAK_CHECKING
2678 g_G2AllocServer = 1;
2679 #endif
2680 //return (int)G2API_RemoveGhoul2Models((CGhoul2Info_v **)args[1]);
2681 return (int)SV_G2API_RemoveGhoul2Models((void **)VMA(1));
2682
2683 case G_G2_CLEANMODELS:
2684 #ifdef _FULL_G2_LEAK_CHECKING
2685 g_G2AllocServer = 1;
2686 #endif
2687 SV_G2API_CleanGhoul2Models((void **)VMA(1));
2688 // re->G2API_CleanGhoul2Models((CGhoul2Info_v **)args[1]);
2689 return 0;
2690
2691 case G_G2_COLLISIONDETECT:
2692 SV_G2API_CollisionDetect ( (CollisionRecord_t*)VMA(1), VMA(2), (const float*)VMA(3), (const float*)VMA(4), args[5], args[6], (float*)VMA(7), (float*)VMA(8), (float*)VMA(9), args[10], args[11], VMF(12) );
2693 return 0;
2694
2695 case G_G2_COLLISIONDETECTCACHE:
2696 SV_G2API_CollisionDetectCache ( (CollisionRecord_t*)VMA(1), VMA(2), (const float*)VMA(3), (const float*)VMA(4), args[5], args[6], (float*)VMA(7), (float*)VMA(8), (float*)VMA(9), args[10], args[11], VMF(12) );
2697 return 0;
2698
2699 case G_G2_SETROOTSURFACE:
2700 return SV_G2API_SetRootSurface(VMA(1), args[2], (const char *)VMA(3));
2701
2702 case G_G2_SETSURFACEONOFF:
2703 return SV_G2API_SetSurfaceOnOff(VMA(1), (const char *)VMA(2), /*(const int)VMA(3)*/args[3]);
2704
2705 case G_G2_SETNEWORIGIN:
2706 return SV_G2API_SetNewOrigin(VMA(1), /*(const int)VMA(2)*/args[2]);
2707
2708 case G_G2_DOESBONEEXIST:
2709 return SV_G2API_DoesBoneExist(VMA(1), args[2], (const char *)VMA(3));
2710
2711 case G_G2_GETSURFACERENDERSTATUS:
2712 return SV_G2API_GetSurfaceRenderStatus(VMA(1), args[2], (const char *)VMA(3));
2713
2714 case G_G2_ABSURDSMOOTHING:
2715 SV_G2API_AbsurdSmoothing(VMA(1), (qboolean)args[2]);
2716 return 0;
2717
2718 case G_G2_SETRAGDOLL:
2719 SV_G2API_SetRagDoll( VMA(1), (sharedRagDollParams_t *)VMA(2) );
2720 return 0;
2721
2722 case G_G2_ANIMATEG2MODELS:
2723 SV_G2API_AnimateG2Models( VMA(1), args[2], (sharedRagDollUpdateParams_t *)VMA(3) );
2724 return 0;
2725
2726 //additional ragdoll options -rww
2727 case G_G2_RAGPCJCONSTRAINT:
2728 return SV_G2API_RagPCJConstraint(VMA(1), (const char *)VMA(2), (float *)VMA(3), (float *)VMA(4));
2729 case G_G2_RAGPCJGRADIENTSPEED:
2730 return SV_G2API_RagPCJGradientSpeed(VMA(1), (const char *)VMA(2), VMF(3));
2731 case G_G2_RAGEFFECTORGOAL:
2732 return SV_G2API_RagEffectorGoal(VMA(1), (const char *)VMA(2), (float *)VMA(3));
2733 case G_G2_GETRAGBONEPOS:
2734 return SV_G2API_GetRagBonePos(VMA(1), (const char *)VMA(2), (float *)VMA(3), (float *)VMA(4), (float *)VMA(5), (float *)VMA(6));
2735 case G_G2_RAGEFFECTORKICK:
2736 return SV_G2API_RagEffectorKick(VMA(1), (const char *)VMA(2), (float *)VMA(3));
2737 case G_G2_RAGFORCESOLVE:
2738 return SV_G2API_RagForceSolve(VMA(1), (qboolean)args[2]);
2739
2740 case G_G2_SETBONEIKSTATE:
2741 return SV_G2API_SetBoneIKState(VMA(1), args[2], (const char *)VMA(3), args[4], (sharedSetBoneIKStateParams_t *)VMA(5));
2742 case G_G2_IKMOVE:
2743 return SV_G2API_IKMove(VMA(1), args[2], (sharedIKMoveParams_t *)VMA(3));
2744
2745 case G_G2_REMOVEBONE:
2746 return SV_G2API_RemoveBone(VMA(1), (const char *)VMA(2), args[3]);
2747
2748 case G_G2_ATTACHINSTANCETOENTNUM:
2749 SV_G2API_AttachInstanceToEntNum(VMA(1), args[2], (qboolean)args[3]);
2750 return 0;
2751 case G_G2_CLEARATTACHEDINSTANCE:
2752 SV_G2API_ClearAttachedInstance(args[1]);
2753 return 0;
2754 case G_G2_CLEANENTATTACHMENTS:
2755 SV_G2API_CleanEntAttachments();
2756 return 0;
2757 case G_G2_OVERRIDESERVER:
2758 return SV_G2API_OverrideServer(VMA(1));
2759
2760 case G_G2_GETSURFACENAME:
2761 SV_G2API_GetSurfaceName(VMA(1), args[2], args[3], (char *)VMA(4));
2762 return 0;
2763
2764 case G_SET_ACTIVE_SUBBSP:
2765 SV_SetActiveSubBSP(args[1]);
2766 return 0;
2767
2768 case G_RMG_INIT:
2769 return 0;
2770
2771 case G_CM_REGISTER_TERRAIN:
2772 return 0;
2773
2774 case G_BOT_UPDATEWAYPOINTS:
2775 SV_BotWaypointReception(args[1], (wpobject_t **)VMA(2));
2776 return 0;
2777 case G_BOT_CALCULATEPATHS:
2778 SV_BotCalculatePaths(args[1]);
2779 return 0;
2780
2781 case G_GET_ENTITY_TOKEN:
2782 return SV_GetEntityToken((char *)VMA(1), args[2]);
2783
2784 default:
2785 Com_Error( ERR_DROP, "Bad game system trap: %ld", (long int) args[0] );
2786 }
2787 return -1;
2788 }
2789
SV_InitGame(qboolean restart)2790 void SV_InitGame( qboolean restart ) {
2791 int i=0;
2792 client_t *cl = NULL;
2793
2794 // clear level pointers
2795 sv.entityParsePoint = CM_EntityString();
2796 for ( i=0, cl=svs.clients; i<sv_maxclients->integer; i++, cl++ )
2797 cl->gentity = NULL;
2798
2799 GVM_InitGame( sv.time, Com_Milliseconds(), restart );
2800 }
2801
SV_BindGame(void)2802 void SV_BindGame( void ) {
2803 static gameImport_t gi;
2804 gameExport_t *ret;
2805 GetGameAPI_t GetGameAPI;
2806 char dllName[MAX_OSPATH] = "jampgame" ARCH_STRING DLL_EXT;
2807
2808 memset( &gi, 0, sizeof( gi ) );
2809
2810 gvm = VM_Create( VM_GAME );
2811 if ( gvm && !gvm->isLegacy ) {
2812 gi.Print = Com_Printf;
2813 gi.Error = Com_Error;
2814 gi.Milliseconds = Com_Milliseconds;
2815 gi.PrecisionTimerStart = SV_PrecisionTimerStart;
2816 gi.PrecisionTimerEnd = SV_PrecisionTimerEnd;
2817 gi.SV_RegisterSharedMemory = SV_RegisterSharedMemory;
2818 gi.RealTime = Com_RealTime;
2819 gi.TrueMalloc = VM_Shifted_Alloc;
2820 gi.TrueFree = VM_Shifted_Free;
2821 gi.SnapVector = Sys_SnapVector;
2822 gi.Cvar_Register = Cvar_Register;
2823 gi.Cvar_Set = GVM_Cvar_Set;
2824 gi.Cvar_Update = Cvar_Update;
2825 gi.Cvar_VariableIntegerValue = Cvar_VariableIntegerValue;
2826 gi.Cvar_VariableStringBuffer = Cvar_VariableStringBuffer;
2827 gi.Argc = Cmd_Argc;
2828 gi.Argv = Cmd_ArgvBuffer;
2829 gi.FS_Close = FS_FCloseFile;
2830 gi.FS_GetFileList = FS_GetFileList;
2831 gi.FS_Open = FS_FOpenFileByMode;
2832 gi.FS_Read = FS_Read;
2833 gi.FS_Write = FS_Write;
2834 gi.AdjustAreaPortalState = SV_AdjustAreaPortalState;
2835 gi.AreasConnected = CM_AreasConnected;
2836 gi.DebugPolygonCreate = BotImport_DebugPolygonCreate;
2837 gi.DebugPolygonDelete = BotImport_DebugPolygonDelete;
2838 gi.DropClient = SV_GameDropClient;
2839 gi.EntitiesInBox = SV_AreaEntities;
2840 gi.EntityContact = SV_EntityContact;
2841 gi.Trace = SV_Trace;
2842 gi.GetConfigstring = SV_GetConfigstring;
2843 gi.GetEntityToken = SV_GetEntityToken;
2844 gi.GetServerinfo = SV_GetServerinfo;
2845 gi.GetUsercmd = SV_GetUsercmd;
2846 gi.GetUserinfo = SV_GetUserinfo;
2847 gi.InPVS = SV_inPVS;
2848 gi.InPVSIgnorePortals = SV_inPVSIgnorePortals;
2849 gi.LinkEntity = SV_LinkEntity;
2850 gi.LocateGameData = SV_LocateGameData;
2851 gi.PointContents = SV_PointContents;
2852 gi.SendConsoleCommand = Cbuf_ExecuteText;
2853 gi.SendServerCommand = SV_GameSendServerCommand;
2854 gi.SetBrushModel = SV_SetBrushModel;
2855 gi.SetConfigstring = SV_SetConfigstring;
2856 gi.SetServerCull = SV_SetServerCull;
2857 gi.SetUserinfo = SV_SetUserinfo;
2858 gi.SiegePersSet = SV_SiegePersSet;
2859 gi.SiegePersGet = SV_SiegePersGet;
2860 gi.UnlinkEntity = SV_UnlinkEntity;
2861 gi.ROFF_Clean = SV_ROFF_Clean;
2862 gi.ROFF_UpdateEntities = SV_ROFF_UpdateEntities;
2863 gi.ROFF_Cache = SV_ROFF_Cache;
2864 gi.ROFF_Play = SV_ROFF_Play;
2865 gi.ROFF_Purge_Ent = SV_ROFF_Purge_Ent;
2866 gi.ICARUS_RunScript = ICARUS_RunScript;
2867 gi.ICARUS_RegisterScript = SV_ICARUS_RegisterScript;
2868 gi.ICARUS_Init = ICARUS_Init;
2869 gi.ICARUS_ValidEnt = SV_ICARUS_ValidEnt;
2870 gi.ICARUS_IsInitialized = ICARUS_IsInitialized;
2871 gi.ICARUS_MaintainTaskManager = ICARUS_MaintainTaskManager;
2872 gi.ICARUS_IsRunning = ICARUS_IsRunning;
2873 gi.ICARUS_TaskIDPending = ICARUS_TaskIDPending;
2874 gi.ICARUS_InitEnt = ICARUS_InitEnt;
2875 gi.ICARUS_FreeEnt = ICARUS_FreeEnt;
2876 gi.ICARUS_AssociateEnt = ICARUS_AssociateEnt;
2877 gi.ICARUS_Shutdown = ICARUS_Shutdown;
2878 gi.ICARUS_TaskIDSet = SV_ICARUS_TaskIDSet;
2879 gi.ICARUS_TaskIDComplete = SV_ICARUS_TaskIDComplete;
2880 gi.ICARUS_SetVar = Q3_SetVar;
2881 gi.ICARUS_VariableDeclared = Q3_VariableDeclared;
2882 gi.ICARUS_GetFloatVariable = Q3_GetFloatVariable;
2883 gi.ICARUS_GetStringVariable = SV_ICARUS_GetStringVariable;
2884 gi.ICARUS_GetVectorVariable = SV_ICARUS_GetVectorVariable;
2885 gi.Nav_Init = SV_Nav_Init;
2886 gi.Nav_Free = SV_Nav_Free;
2887 gi.Nav_Load = SV_Nav_Load;
2888 gi.Nav_Save = SV_Nav_Save;
2889 gi.Nav_AddRawPoint = SV_Nav_AddRawPoint;
2890 gi.Nav_CalculatePaths = SV_Nav_CalculatePaths;
2891 gi.Nav_HardConnect = SV_Nav_HardConnect;
2892 gi.Nav_ShowNodes = SV_Nav_ShowNodes;
2893 gi.Nav_ShowEdges = SV_Nav_ShowEdges;
2894 gi.Nav_ShowPath = SV_Nav_ShowPath;
2895 gi.Nav_GetNearestNode = SV_Nav_GetNearestNode;
2896 gi.Nav_GetBestNode = SV_Nav_GetBestNode;
2897 gi.Nav_GetNodePosition = SV_Nav_GetNodePosition;
2898 gi.Nav_GetNodeNumEdges = SV_Nav_GetNodeNumEdges;
2899 gi.Nav_GetNodeEdge = SV_Nav_GetNodeEdge;
2900 gi.Nav_GetNumNodes = SV_Nav_GetNumNodes;
2901 gi.Nav_Connected = SV_Nav_Connected;
2902 gi.Nav_GetPathCost = SV_Nav_GetPathCost;
2903 gi.Nav_GetEdgeCost = SV_Nav_GetEdgeCost;
2904 gi.Nav_GetProjectedNode = SV_Nav_GetProjectedNode;
2905 gi.Nav_CheckFailedNodes = SV_Nav_CheckFailedNodes;
2906 gi.Nav_AddFailedNode = SV_Nav_AddFailedNode;
2907 gi.Nav_NodeFailed = SV_Nav_NodeFailed;
2908 gi.Nav_NodesAreNeighbors = SV_Nav_NodesAreNeighbors;
2909 gi.Nav_ClearFailedEdge = SV_Nav_ClearFailedEdge;
2910 gi.Nav_ClearAllFailedEdges = SV_Nav_ClearAllFailedEdges;
2911 gi.Nav_EdgeFailed = SV_Nav_EdgeFailed;
2912 gi.Nav_AddFailedEdge = SV_Nav_AddFailedEdge;
2913 gi.Nav_CheckFailedEdge = SV_Nav_CheckFailedEdge;
2914 gi.Nav_CheckAllFailedEdges = SV_Nav_CheckAllFailedEdges;
2915 gi.Nav_RouteBlocked = SV_Nav_RouteBlocked;
2916 gi.Nav_GetBestNodeAltRoute = SV_Nav_GetBestNodeAltRoute;
2917 gi.Nav_GetBestNodeAltRoute2 = SV_Nav_GetBestNodeAltRoute2;
2918 gi.Nav_GetBestPathBetweenEnts = SV_Nav_GetBestPathBetweenEnts;
2919 gi.Nav_GetNodeRadius = SV_Nav_GetNodeRadius;
2920 gi.Nav_CheckBlockedEdges = SV_Nav_CheckBlockedEdges;
2921 gi.Nav_ClearCheckedNodes = SV_Nav_ClearCheckedNodes;
2922 gi.Nav_CheckedNode = SV_Nav_CheckedNode;
2923 gi.Nav_SetCheckedNode = SV_Nav_SetCheckedNode;
2924 gi.Nav_FlagAllNodes = SV_Nav_FlagAllNodes;
2925 gi.Nav_GetPathsCalculated = SV_Nav_GetPathsCalculated;
2926 gi.Nav_SetPathsCalculated = SV_Nav_SetPathsCalculated;
2927 gi.BotAllocateClient = SV_BotAllocateClient;
2928 gi.BotFreeClient = SV_BotFreeClient;
2929 gi.BotLoadCharacter = SV_BotLoadCharacter;
2930 gi.BotFreeCharacter = SV_BotFreeCharacter;
2931 gi.Characteristic_Float = SV_Characteristic_Float;
2932 gi.Characteristic_BFloat = SV_Characteristic_BFloat;
2933 gi.Characteristic_Integer = SV_Characteristic_Integer;
2934 gi.Characteristic_BInteger = SV_Characteristic_BInteger;
2935 gi.Characteristic_String = SV_Characteristic_String;
2936 gi.BotAllocChatState = SV_BotAllocChatState;
2937 gi.BotFreeChatState = SV_BotFreeChatState;
2938 gi.BotQueueConsoleMessage = SV_BotQueueConsoleMessage;
2939 gi.BotRemoveConsoleMessage = SV_BotRemoveConsoleMessage;
2940 gi.BotNextConsoleMessage = SV_BotNextConsoleMessage;
2941 gi.BotNumConsoleMessages = SV_BotNumConsoleMessages;
2942 gi.BotInitialChat = SV_BotInitialChat;
2943 gi.BotReplyChat = SV_BotReplyChat;
2944 gi.BotChatLength = SV_BotChatLength;
2945 gi.BotEnterChat = SV_BotEnterChat;
2946 gi.StringContains = SV_StringContains;
2947 gi.BotFindMatch = SV_BotFindMatch;
2948 gi.BotMatchVariable = SV_BotMatchVariable;
2949 gi.UnifyWhiteSpaces = SV_UnifyWhiteSpaces;
2950 gi.BotReplaceSynonyms = SV_BotReplaceSynonyms;
2951 gi.BotLoadChatFile = SV_BotLoadChatFile;
2952 gi.BotSetChatGender = SV_BotSetChatGender;
2953 gi.BotSetChatName = SV_BotSetChatName;
2954 gi.BotResetGoalState = SV_BotResetGoalState;
2955 gi.BotResetAvoidGoals = SV_BotResetAvoidGoals;
2956 gi.BotPushGoal = SV_BotPushGoal;
2957 gi.BotPopGoal = SV_BotPopGoal;
2958 gi.BotEmptyGoalStack = SV_BotEmptyGoalStack;
2959 gi.BotDumpAvoidGoals = SV_BotDumpAvoidGoals;
2960 gi.BotDumpGoalStack = SV_BotDumpGoalStack;
2961 gi.BotGoalName = SV_BotGoalName;
2962 gi.BotGetTopGoal = SV_BotGetTopGoal;
2963 gi.BotGetSecondGoal = SV_BotGetSecondGoal;
2964 gi.BotChooseLTGItem = SV_BotChooseLTGItem;
2965 gi.BotChooseNBGItem = SV_BotChooseNBGItem;
2966 gi.BotTouchingGoal = SV_BotTouchingGoal;
2967 gi.BotItemGoalInVisButNotVisible = SV_BotItemGoalInVisButNotVisible;
2968 gi.BotGetLevelItemGoal = SV_BotGetLevelItemGoal;
2969 gi.BotAvoidGoalTime = SV_BotAvoidGoalTime;
2970 gi.BotInitLevelItems = SV_BotInitLevelItems;
2971 gi.BotUpdateEntityItems = SV_BotUpdateEntityItems;
2972 gi.BotLoadItemWeights = SV_BotLoadItemWeights;
2973 gi.BotFreeItemWeights = SV_BotFreeItemWeights;
2974 gi.BotSaveGoalFuzzyLogic = SV_BotSaveGoalFuzzyLogic;
2975 gi.BotAllocGoalState = SV_BotAllocGoalState;
2976 gi.BotFreeGoalState = SV_BotFreeGoalState;
2977 gi.BotResetMoveState = SV_BotResetMoveState;
2978 gi.BotMoveToGoal = SV_BotMoveToGoal;
2979 gi.BotMoveInDirection = SV_BotMoveInDirection;
2980 gi.BotResetAvoidReach = SV_BotResetAvoidReach;
2981 gi.BotResetLastAvoidReach = SV_BotResetLastAvoidReach;
2982 gi.BotReachabilityArea = SV_BotReachabilityArea;
2983 gi.BotMovementViewTarget = SV_BotMovementViewTarget;
2984 gi.BotAllocMoveState = SV_BotAllocMoveState;
2985 gi.BotFreeMoveState = SV_BotFreeMoveState;
2986 gi.BotInitMoveState = SV_BotInitMoveState;
2987 gi.BotChooseBestFightWeapon = SV_BotChooseBestFightWeapon;
2988 gi.BotGetWeaponInfo = SV_BotGetWeaponInfo;
2989 gi.BotLoadWeaponWeights = SV_BotLoadWeaponWeights;
2990 gi.BotAllocWeaponState = SV_BotAllocWeaponState;
2991 gi.BotFreeWeaponState = SV_BotFreeWeaponState;
2992 gi.BotResetWeaponState = SV_BotResetWeaponState;
2993 gi.GeneticParentsAndChildSelection = SV_GeneticParentsAndChildSelection;
2994 gi.BotInterbreedGoalFuzzyLogic = SV_BotInterbreedGoalFuzzyLogic;
2995 gi.BotMutateGoalFuzzyLogic = SV_BotMutateGoalFuzzyLogic;
2996 gi.BotGetNextCampSpotGoal = SV_BotGetNextCampSpotGoal;
2997 gi.BotGetMapLocationGoal = SV_BotGetMapLocationGoal;
2998 gi.BotNumInitialChats = SV_BotNumInitialChats;
2999 gi.BotGetChatMessage = SV_BotGetChatMessage;
3000 gi.BotRemoveFromAvoidGoals = SV_BotRemoveFromAvoidGoals;
3001 gi.BotPredictVisiblePosition = SV_BotPredictVisiblePosition;
3002 gi.BotSetAvoidGoalTime = SV_BotSetAvoidGoalTime;
3003 gi.BotAddAvoidSpot = SV_BotAddAvoidSpot;
3004 gi.BotLibSetup = SV_BotLibSetup;
3005 gi.BotLibShutdown = SV_BotLibShutdown;
3006 gi.BotLibVarSet = SV_BotLibVarSet;
3007 gi.BotLibVarGet = SV_BotLibVarGet;
3008 gi.BotLibDefine = SV_BotLibDefine;
3009 gi.BotLibStartFrame = SV_BotLibStartFrame;
3010 gi.BotLibLoadMap = SV_BotLibLoadMap;
3011 gi.BotLibUpdateEntity = SV_BotLibUpdateEntity;
3012 gi.BotLibTest = SV_BotLibTest;
3013 gi.BotGetSnapshotEntity = SV_BotGetSnapshotEntity;
3014 gi.BotGetServerCommand = SV_BotGetServerCommand;
3015 gi.BotUserCommand = SV_BotUserCommand;
3016 gi.BotUpdateWaypoints = SV_BotWaypointReception;
3017 gi.BotCalculatePaths = SV_BotCalculatePaths;
3018 gi.AAS_EnableRoutingArea = SV_AAS_EnableRoutingArea;
3019 gi.AAS_BBoxAreas = SV_AAS_BBoxAreas;
3020 gi.AAS_AreaInfo = SV_AAS_AreaInfo;
3021 gi.AAS_EntityInfo = SV_AAS_EntityInfo;
3022 gi.AAS_Initialized = SV_AAS_Initialized;
3023 gi.AAS_PresenceTypeBoundingBox = SV_AAS_PresenceTypeBoundingBox;
3024 gi.AAS_Time = SV_AAS_Time;
3025 gi.AAS_PointAreaNum = SV_AAS_PointAreaNum;
3026 gi.AAS_TraceAreas = SV_AAS_TraceAreas;
3027 gi.AAS_PointContents = SV_AAS_PointContents;
3028 gi.AAS_NextBSPEntity = SV_AAS_NextBSPEntity;
3029 gi.AAS_ValueForBSPEpairKey = SV_AAS_ValueForBSPEpairKey;
3030 gi.AAS_VectorForBSPEpairKey = SV_AAS_VectorForBSPEpairKey;
3031 gi.AAS_FloatForBSPEpairKey = SV_AAS_FloatForBSPEpairKey;
3032 gi.AAS_IntForBSPEpairKey = SV_AAS_IntForBSPEpairKey;
3033 gi.AAS_AreaReachability = SV_AAS_AreaReachability;
3034 gi.AAS_AreaTravelTimeToGoalArea = SV_AAS_AreaTravelTimeToGoalArea;
3035 gi.AAS_Swimming = SV_AAS_Swimming;
3036 gi.AAS_PredictClientMovement = SV_AAS_PredictClientMovement;
3037 gi.AAS_AlternativeRouteGoals = SV_AAS_AlternativeRouteGoals;
3038 gi.AAS_PredictRoute = SV_AAS_PredictRoute;
3039 gi.AAS_PointReachabilityAreaIndex = SV_AAS_PointReachabilityAreaIndex;
3040 gi.EA_Say = SV_EA_Say;
3041 gi.EA_SayTeam = SV_EA_SayTeam;
3042 gi.EA_Command = SV_EA_Command;
3043 gi.EA_Action = SV_EA_Action;
3044 gi.EA_Gesture = SV_EA_Gesture;
3045 gi.EA_Talk = SV_EA_Talk;
3046 gi.EA_Attack = SV_EA_Attack;
3047 gi.EA_Alt_Attack = SV_EA_Alt_Attack;
3048 gi.EA_ForcePower = SV_EA_ForcePower;
3049 gi.EA_Use = SV_EA_Use;
3050 gi.EA_Respawn = SV_EA_Respawn;
3051 gi.EA_Crouch = SV_EA_Crouch;
3052 gi.EA_MoveUp = SV_EA_MoveUp;
3053 gi.EA_MoveDown = SV_EA_MoveDown;
3054 gi.EA_MoveForward = SV_EA_MoveForward;
3055 gi.EA_MoveBack = SV_EA_MoveBack;
3056 gi.EA_MoveLeft = SV_EA_MoveLeft;
3057 gi.EA_MoveRight = SV_EA_MoveRight;
3058 gi.EA_SelectWeapon = SV_EA_SelectWeapon;
3059 gi.EA_Jump = SV_EA_Jump;
3060 gi.EA_DelayedJump = SV_EA_DelayedJump;
3061 gi.EA_Move = SV_EA_Move;
3062 gi.EA_View = SV_EA_View;
3063 gi.EA_EndRegular = SV_EA_EndRegular;
3064 gi.EA_GetInput = SV_EA_GetInput;
3065 gi.EA_ResetInput = SV_EA_ResetInput;
3066 gi.PC_LoadSource = SV_PC_LoadSource;
3067 gi.PC_FreeSource = SV_PC_FreeSource;
3068 gi.PC_ReadToken = SV_PC_ReadToken;
3069 gi.PC_SourceFileAndLine = SV_PC_SourceFileAndLine;
3070 gi.R_RegisterSkin = SV_RE_RegisterSkin;
3071 gi.SetActiveSubBSP = SV_SetActiveSubBSP;
3072 gi.CM_RegisterTerrain = SV_CM_RegisterTerrain;
3073 gi.RMG_Init = SV_RMG_Init;
3074 gi.G2API_ListModelBones = SV_G2API_ListModelBones;
3075 gi.G2API_ListModelSurfaces = SV_G2API_ListModelSurfaces;
3076 gi.G2API_HaveWeGhoul2Models = SV_G2API_HaveWeGhoul2Models;
3077 gi.G2API_SetGhoul2ModelIndexes = SV_G2API_SetGhoul2ModelIndexes;
3078 gi.G2API_GetBoltMatrix = SV_G2API_GetBoltMatrix;
3079 gi.G2API_GetBoltMatrix_NoReconstruct = SV_G2API_GetBoltMatrix_NoReconstruct;
3080 gi.G2API_GetBoltMatrix_NoRecNoRot = SV_G2API_GetBoltMatrix_NoRecNoRot;
3081 gi.G2API_InitGhoul2Model = SV_G2API_InitGhoul2Model;
3082 gi.G2API_SetSkin = SV_G2API_SetSkin;
3083 gi.G2API_Ghoul2Size = SV_G2API_Ghoul2Size;
3084 gi.G2API_AddBolt = SV_G2API_AddBolt;
3085 gi.G2API_SetBoltInfo = SV_G2API_SetBoltInfo;
3086 gi.G2API_SetBoneAngles = SV_G2API_SetBoneAngles;
3087 gi.G2API_SetBoneAnim = SV_G2API_SetBoneAnim;
3088 gi.G2API_GetBoneAnim = SV_G2API_GetBoneAnim;
3089 gi.G2API_GetGLAName = SV_G2API_GetGLAName;
3090 gi.G2API_CopyGhoul2Instance = SV_G2API_CopyGhoul2Instance;
3091 gi.G2API_CopySpecificGhoul2Model = SV_G2API_CopySpecificGhoul2Model;
3092 gi.G2API_DuplicateGhoul2Instance = SV_G2API_DuplicateGhoul2Instance;
3093 gi.G2API_HasGhoul2ModelOnIndex = SV_G2API_HasGhoul2ModelOnIndex;
3094 gi.G2API_RemoveGhoul2Model = SV_G2API_RemoveGhoul2Model;
3095 gi.G2API_RemoveGhoul2Models = SV_G2API_RemoveGhoul2Models;
3096 gi.G2API_CleanGhoul2Models = SV_G2API_CleanGhoul2Models;
3097 gi.G2API_CollisionDetect = SV_G2API_CollisionDetect;
3098 gi.G2API_CollisionDetectCache = SV_G2API_CollisionDetectCache;
3099 gi.G2API_SetRootSurface = SV_G2API_SetRootSurface;
3100 gi.G2API_SetSurfaceOnOff = SV_G2API_SetSurfaceOnOff;
3101 gi.G2API_SetNewOrigin = SV_G2API_SetNewOrigin;
3102 gi.G2API_DoesBoneExist = SV_G2API_DoesBoneExist;
3103 gi.G2API_GetSurfaceRenderStatus = SV_G2API_GetSurfaceRenderStatus;
3104 gi.G2API_AbsurdSmoothing = SV_G2API_AbsurdSmoothing;
3105 gi.G2API_SetRagDoll = SV_G2API_SetRagDoll;
3106 gi.G2API_AnimateG2Models = SV_G2API_AnimateG2Models;
3107 gi.G2API_RagPCJConstraint = SV_G2API_RagPCJConstraint;
3108 gi.G2API_RagPCJGradientSpeed = SV_G2API_RagPCJGradientSpeed;
3109 gi.G2API_RagEffectorGoal = SV_G2API_RagEffectorGoal;
3110 gi.G2API_GetRagBonePos = SV_G2API_GetRagBonePos;
3111 gi.G2API_RagEffectorKick = SV_G2API_RagEffectorKick;
3112 gi.G2API_RagForceSolve = SV_G2API_RagForceSolve;
3113 gi.G2API_SetBoneIKState = SV_G2API_SetBoneIKState;
3114 gi.G2API_IKMove = SV_G2API_IKMove;
3115 gi.G2API_RemoveBone = SV_G2API_RemoveBone;
3116 gi.G2API_AttachInstanceToEntNum = SV_G2API_AttachInstanceToEntNum;
3117 gi.G2API_ClearAttachedInstance = SV_G2API_ClearAttachedInstance;
3118 gi.G2API_CleanEntAttachments = SV_G2API_CleanEntAttachments;
3119 gi.G2API_OverrideServer = SV_G2API_OverrideServer;
3120 gi.G2API_GetSurfaceName = SV_G2API_GetSurfaceName;
3121
3122 GetGameAPI = (GetGameAPI_t)gvm->GetModuleAPI;
3123 ret = GetGameAPI( GAME_API_VERSION, &gi );
3124 if ( !ret ) {
3125 //free VM?
3126 svs.gameStarted = qfalse;
3127 Com_Error( ERR_FATAL, "GetGameAPI failed on %s", dllName );
3128 }
3129 ge = ret;
3130
3131 return;
3132 }
3133
3134 // fall back to legacy syscall/vm_call api
3135 gvm = VM_CreateLegacy( VM_GAME, SV_GameSystemCalls );
3136 if ( !gvm ) {
3137 svs.gameStarted = qfalse;
3138 Com_Error( ERR_DROP, "VM_CreateLegacy on game failed" );
3139 }
3140 }
3141
SV_UnbindGame(void)3142 void SV_UnbindGame( void ) {
3143 GVM_ShutdownGame( qfalse );
3144 VM_Free( gvm );
3145 gvm = NULL;
3146 }
3147
SV_RestartGame(void)3148 void SV_RestartGame( void ) {
3149 GVM_ShutdownGame( qtrue );
3150
3151 gvm = VM_Restart( gvm );
3152 SV_BindGame();
3153 if ( !gvm ) {
3154 svs.gameStarted = qfalse;
3155 Com_Error( ERR_DROP, "VM_Restart on game failed" );
3156 return;
3157 }
3158
3159 SV_InitGame( qtrue );
3160 }
3161