g_syscalls.c (25157B)
1 /* 2 =========================================================================== 3 Copyright (C) 1999-2005 Id Software, Inc. 4 5 This file is part of Quake III Arena source code. 6 7 Quake III Arena source code is free software; you can redistribute it 8 and/or modify it under the terms of the GNU General Public License as 9 published by the Free Software Foundation; either version 2 of the License, 10 or (at your option) any later version. 11 12 Quake III Arena source code is distributed in the hope that it will be 13 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with Foobar; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 20 =========================================================================== 21 */ 22 // 23 #include "g_local.h" 24 25 // this file is only included when building a dll 26 // g_syscalls.asm is included instead when building a qvm 27 #ifdef Q3_VM 28 #error "Do not use in VM build" 29 #endif 30 31 static int (QDECL *syscall)( int arg, ... ) = (int (QDECL *)( int, ...))-1; 32 33 34 void dllEntry( int (QDECL *syscallptr)( int arg,... ) ) { 35 syscall = syscallptr; 36 } 37 38 int PASSFLOAT( float x ) { 39 float floatTemp; 40 floatTemp = x; 41 return *(int *)&floatTemp; 42 } 43 44 void trap_Printf( const char *fmt ) { 45 syscall( G_PRINT, fmt ); 46 } 47 48 void trap_Error( const char *fmt ) { 49 syscall( G_ERROR, fmt ); 50 } 51 52 int trap_Milliseconds( void ) { 53 return syscall( G_MILLISECONDS ); 54 } 55 int trap_Argc( void ) { 56 return syscall( G_ARGC ); 57 } 58 59 void trap_Argv( int n, char *buffer, int bufferLength ) { 60 syscall( G_ARGV, n, buffer, bufferLength ); 61 } 62 63 int trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode ) { 64 return syscall( G_FS_FOPEN_FILE, qpath, f, mode ); 65 } 66 67 void trap_FS_Read( void *buffer, int len, fileHandle_t f ) { 68 syscall( G_FS_READ, buffer, len, f ); 69 } 70 71 void trap_FS_Write( const void *buffer, int len, fileHandle_t f ) { 72 syscall( G_FS_WRITE, buffer, len, f ); 73 } 74 75 void trap_FS_FCloseFile( fileHandle_t f ) { 76 syscall( G_FS_FCLOSE_FILE, f ); 77 } 78 79 int trap_FS_GetFileList( const char *path, const char *extension, char *listbuf, int bufsize ) { 80 return syscall( G_FS_GETFILELIST, path, extension, listbuf, bufsize ); 81 } 82 83 int trap_FS_Seek( fileHandle_t f, long offset, int origin ) { 84 return syscall( G_FS_SEEK, f, offset, origin ); 85 } 86 87 void trap_SendConsoleCommand( int exec_when, const char *text ) { 88 syscall( G_SEND_CONSOLE_COMMAND, exec_when, text ); 89 } 90 91 void trap_Cvar_Register( vmCvar_t *cvar, const char *var_name, const char *value, int flags ) { 92 syscall( G_CVAR_REGISTER, cvar, var_name, value, flags ); 93 } 94 95 void trap_Cvar_Update( vmCvar_t *cvar ) { 96 syscall( G_CVAR_UPDATE, cvar ); 97 } 98 99 void trap_Cvar_Set( const char *var_name, const char *value ) { 100 syscall( G_CVAR_SET, var_name, value ); 101 } 102 103 int trap_Cvar_VariableIntegerValue( const char *var_name ) { 104 return syscall( G_CVAR_VARIABLE_INTEGER_VALUE, var_name ); 105 } 106 107 void trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize ) { 108 syscall( G_CVAR_VARIABLE_STRING_BUFFER, var_name, buffer, bufsize ); 109 } 110 111 112 void trap_LocateGameData( gentity_t *gEnts, int numGEntities, int sizeofGEntity_t, 113 playerState_t *clients, int sizeofGClient ) { 114 syscall( G_LOCATE_GAME_DATA, gEnts, numGEntities, sizeofGEntity_t, clients, sizeofGClient ); 115 } 116 117 void trap_DropClient( int clientNum, const char *reason ) { 118 syscall( G_DROP_CLIENT, clientNum, reason ); 119 } 120 121 void trap_SendServerCommand( int clientNum, const char *text ) { 122 syscall( G_SEND_SERVER_COMMAND, clientNum, text ); 123 } 124 125 void trap_SetConfigstring( int num, const char *string ) { 126 syscall( G_SET_CONFIGSTRING, num, string ); 127 } 128 129 void trap_GetConfigstring( int num, char *buffer, int bufferSize ) { 130 syscall( G_GET_CONFIGSTRING, num, buffer, bufferSize ); 131 } 132 133 void trap_GetUserinfo( int num, char *buffer, int bufferSize ) { 134 syscall( G_GET_USERINFO, num, buffer, bufferSize ); 135 } 136 137 void trap_SetUserinfo( int num, const char *buffer ) { 138 syscall( G_SET_USERINFO, num, buffer ); 139 } 140 141 void trap_GetServerinfo( char *buffer, int bufferSize ) { 142 syscall( G_GET_SERVERINFO, buffer, bufferSize ); 143 } 144 145 void trap_SetBrushModel( gentity_t *ent, const char *name ) { 146 syscall( G_SET_BRUSH_MODEL, ent, name ); 147 } 148 149 void trap_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask ) { 150 syscall( G_TRACE, results, start, mins, maxs, end, passEntityNum, contentmask ); 151 } 152 153 void trap_TraceCapsule( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask ) { 154 syscall( G_TRACECAPSULE, results, start, mins, maxs, end, passEntityNum, contentmask ); 155 } 156 157 int trap_PointContents( const vec3_t point, int passEntityNum ) { 158 return syscall( G_POINT_CONTENTS, point, passEntityNum ); 159 } 160 161 162 qboolean trap_InPVS( const vec3_t p1, const vec3_t p2 ) { 163 return syscall( G_IN_PVS, p1, p2 ); 164 } 165 166 qboolean trap_InPVSIgnorePortals( const vec3_t p1, const vec3_t p2 ) { 167 return syscall( G_IN_PVS_IGNORE_PORTALS, p1, p2 ); 168 } 169 170 void trap_AdjustAreaPortalState( gentity_t *ent, qboolean open ) { 171 syscall( G_ADJUST_AREA_PORTAL_STATE, ent, open ); 172 } 173 174 qboolean trap_AreasConnected( int area1, int area2 ) { 175 return syscall( G_AREAS_CONNECTED, area1, area2 ); 176 } 177 178 void trap_LinkEntity( gentity_t *ent ) { 179 syscall( G_LINKENTITY, ent ); 180 } 181 182 void trap_UnlinkEntity( gentity_t *ent ) { 183 syscall( G_UNLINKENTITY, ent ); 184 } 185 186 int trap_EntitiesInBox( const vec3_t mins, const vec3_t maxs, int *list, int maxcount ) { 187 return syscall( G_ENTITIES_IN_BOX, mins, maxs, list, maxcount ); 188 } 189 190 qboolean trap_EntityContact( const vec3_t mins, const vec3_t maxs, const gentity_t *ent ) { 191 return syscall( G_ENTITY_CONTACT, mins, maxs, ent ); 192 } 193 194 qboolean trap_EntityContactCapsule( const vec3_t mins, const vec3_t maxs, const gentity_t *ent ) { 195 return syscall( G_ENTITY_CONTACTCAPSULE, mins, maxs, ent ); 196 } 197 198 int trap_BotAllocateClient( void ) { 199 return syscall( G_BOT_ALLOCATE_CLIENT ); 200 } 201 202 void trap_BotFreeClient( int clientNum ) { 203 syscall( G_BOT_FREE_CLIENT, clientNum ); 204 } 205 206 void trap_GetUsercmd( int clientNum, usercmd_t *cmd ) { 207 syscall( G_GET_USERCMD, clientNum, cmd ); 208 } 209 210 qboolean trap_GetEntityToken( char *buffer, int bufferSize ) { 211 return syscall( G_GET_ENTITY_TOKEN, buffer, bufferSize ); 212 } 213 214 int trap_DebugPolygonCreate(int color, int numPoints, vec3_t *points) { 215 return syscall( G_DEBUG_POLYGON_CREATE, color, numPoints, points ); 216 } 217 218 void trap_DebugPolygonDelete(int id) { 219 syscall( G_DEBUG_POLYGON_DELETE, id ); 220 } 221 222 int trap_RealTime( qtime_t *qtime ) { 223 return syscall( G_REAL_TIME, qtime ); 224 } 225 226 void trap_SnapVector( float *v ) { 227 syscall( G_SNAPVECTOR, v ); 228 return; 229 } 230 231 // BotLib traps start here 232 int trap_BotLibSetup( void ) { 233 return syscall( BOTLIB_SETUP ); 234 } 235 236 int trap_BotLibShutdown( void ) { 237 return syscall( BOTLIB_SHUTDOWN ); 238 } 239 240 int trap_BotLibVarSet(char *var_name, char *value) { 241 return syscall( BOTLIB_LIBVAR_SET, var_name, value ); 242 } 243 244 int trap_BotLibVarGet(char *var_name, char *value, int size) { 245 return syscall( BOTLIB_LIBVAR_GET, var_name, value, size ); 246 } 247 248 int trap_BotLibDefine(char *string) { 249 return syscall( BOTLIB_PC_ADD_GLOBAL_DEFINE, string ); 250 } 251 252 int trap_BotLibStartFrame(float time) { 253 return syscall( BOTLIB_START_FRAME, PASSFLOAT( time ) ); 254 } 255 256 int trap_BotLibLoadMap(const char *mapname) { 257 return syscall( BOTLIB_LOAD_MAP, mapname ); 258 } 259 260 int trap_BotLibUpdateEntity(int ent, void /* struct bot_updateentity_s */ *bue) { 261 return syscall( BOTLIB_UPDATENTITY, ent, bue ); 262 } 263 264 int trap_BotLibTest(int parm0, char *parm1, vec3_t parm2, vec3_t parm3) { 265 return syscall( BOTLIB_TEST, parm0, parm1, parm2, parm3 ); 266 } 267 268 int trap_BotGetSnapshotEntity( int clientNum, int sequence ) { 269 return syscall( BOTLIB_GET_SNAPSHOT_ENTITY, clientNum, sequence ); 270 } 271 272 int trap_BotGetServerCommand(int clientNum, char *message, int size) { 273 return syscall( BOTLIB_GET_CONSOLE_MESSAGE, clientNum, message, size ); 274 } 275 276 void trap_BotUserCommand(int clientNum, usercmd_t *ucmd) { 277 syscall( BOTLIB_USER_COMMAND, clientNum, ucmd ); 278 } 279 280 void trap_AAS_EntityInfo(int entnum, void /* struct aas_entityinfo_s */ *info) { 281 syscall( BOTLIB_AAS_ENTITY_INFO, entnum, info ); 282 } 283 284 int trap_AAS_Initialized(void) { 285 return syscall( BOTLIB_AAS_INITIALIZED ); 286 } 287 288 void trap_AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs) { 289 syscall( BOTLIB_AAS_PRESENCE_TYPE_BOUNDING_BOX, presencetype, mins, maxs ); 290 } 291 292 float trap_AAS_Time(void) { 293 int temp; 294 temp = syscall( BOTLIB_AAS_TIME ); 295 return (*(float*)&temp); 296 } 297 298 int trap_AAS_PointAreaNum(vec3_t point) { 299 return syscall( BOTLIB_AAS_POINT_AREA_NUM, point ); 300 } 301 302 int trap_AAS_PointReachabilityAreaIndex(vec3_t point) { 303 return syscall( BOTLIB_AAS_POINT_REACHABILITY_AREA_INDEX, point ); 304 } 305 306 int trap_AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas) { 307 return syscall( BOTLIB_AAS_TRACE_AREAS, start, end, areas, points, maxareas ); 308 } 309 310 int trap_AAS_BBoxAreas(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas) { 311 return syscall( BOTLIB_AAS_BBOX_AREAS, absmins, absmaxs, areas, maxareas ); 312 } 313 314 int trap_AAS_AreaInfo( int areanum, void /* struct aas_areainfo_s */ *info ) { 315 return syscall( BOTLIB_AAS_AREA_INFO, areanum, info ); 316 } 317 318 int trap_AAS_PointContents(vec3_t point) { 319 return syscall( BOTLIB_AAS_POINT_CONTENTS, point ); 320 } 321 322 int trap_AAS_NextBSPEntity(int ent) { 323 return syscall( BOTLIB_AAS_NEXT_BSP_ENTITY, ent ); 324 } 325 326 int trap_AAS_ValueForBSPEpairKey(int ent, char *key, char *value, int size) { 327 return syscall( BOTLIB_AAS_VALUE_FOR_BSP_EPAIR_KEY, ent, key, value, size ); 328 } 329 330 int trap_AAS_VectorForBSPEpairKey(int ent, char *key, vec3_t v) { 331 return syscall( BOTLIB_AAS_VECTOR_FOR_BSP_EPAIR_KEY, ent, key, v ); 332 } 333 334 int trap_AAS_FloatForBSPEpairKey(int ent, char *key, float *value) { 335 return syscall( BOTLIB_AAS_FLOAT_FOR_BSP_EPAIR_KEY, ent, key, value ); 336 } 337 338 int trap_AAS_IntForBSPEpairKey(int ent, char *key, int *value) { 339 return syscall( BOTLIB_AAS_INT_FOR_BSP_EPAIR_KEY, ent, key, value ); 340 } 341 342 int trap_AAS_AreaReachability(int areanum) { 343 return syscall( BOTLIB_AAS_AREA_REACHABILITY, areanum ); 344 } 345 346 int trap_AAS_AreaTravelTimeToGoalArea(int areanum, vec3_t origin, int goalareanum, int travelflags) { 347 return syscall( BOTLIB_AAS_AREA_TRAVEL_TIME_TO_GOAL_AREA, areanum, origin, goalareanum, travelflags ); 348 } 349 350 int trap_AAS_EnableRoutingArea( int areanum, int enable ) { 351 return syscall( BOTLIB_AAS_ENABLE_ROUTING_AREA, areanum, enable ); 352 } 353 354 int trap_AAS_PredictRoute(void /*struct aas_predictroute_s*/ *route, int areanum, vec3_t origin, 355 int goalareanum, int travelflags, int maxareas, int maxtime, 356 int stopevent, int stopcontents, int stoptfl, int stopareanum) { 357 return syscall( BOTLIB_AAS_PREDICT_ROUTE, route, areanum, origin, goalareanum, travelflags, maxareas, maxtime, stopevent, stopcontents, stoptfl, stopareanum ); 358 } 359 360 int trap_AAS_AlternativeRouteGoals(vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags, 361 void /*struct aas_altroutegoal_s*/ *altroutegoals, int maxaltroutegoals, 362 int type) { 363 return syscall( BOTLIB_AAS_ALTERNATIVE_ROUTE_GOAL, start, startareanum, goal, goalareanum, travelflags, altroutegoals, maxaltroutegoals, type ); 364 } 365 366 int trap_AAS_Swimming(vec3_t origin) { 367 return syscall( BOTLIB_AAS_SWIMMING, origin ); 368 } 369 370 int trap_AAS_PredictClientMovement(void /* struct aas_clientmove_s */ *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) { 371 return syscall( BOTLIB_AAS_PREDICT_CLIENT_MOVEMENT, move, entnum, origin, presencetype, onground, velocity, cmdmove, cmdframes, maxframes, PASSFLOAT(frametime), stopevent, stopareanum, visualize ); 372 } 373 374 void trap_EA_Say(int client, char *str) { 375 syscall( BOTLIB_EA_SAY, client, str ); 376 } 377 378 void trap_EA_SayTeam(int client, char *str) { 379 syscall( BOTLIB_EA_SAY_TEAM, client, str ); 380 } 381 382 void trap_EA_Command(int client, char *command) { 383 syscall( BOTLIB_EA_COMMAND, client, command ); 384 } 385 386 void trap_EA_Action(int client, int action) { 387 syscall( BOTLIB_EA_ACTION, client, action ); 388 } 389 390 void trap_EA_Gesture(int client) { 391 syscall( BOTLIB_EA_GESTURE, client ); 392 } 393 394 void trap_EA_Talk(int client) { 395 syscall( BOTLIB_EA_TALK, client ); 396 } 397 398 void trap_EA_Attack(int client) { 399 syscall( BOTLIB_EA_ATTACK, client ); 400 } 401 402 void trap_EA_Use(int client) { 403 syscall( BOTLIB_EA_USE, client ); 404 } 405 406 void trap_EA_Respawn(int client) { 407 syscall( BOTLIB_EA_RESPAWN, client ); 408 } 409 410 void trap_EA_Crouch(int client) { 411 syscall( BOTLIB_EA_CROUCH, client ); 412 } 413 414 void trap_EA_MoveUp(int client) { 415 syscall( BOTLIB_EA_MOVE_UP, client ); 416 } 417 418 void trap_EA_MoveDown(int client) { 419 syscall( BOTLIB_EA_MOVE_DOWN, client ); 420 } 421 422 void trap_EA_MoveForward(int client) { 423 syscall( BOTLIB_EA_MOVE_FORWARD, client ); 424 } 425 426 void trap_EA_MoveBack(int client) { 427 syscall( BOTLIB_EA_MOVE_BACK, client ); 428 } 429 430 void trap_EA_MoveLeft(int client) { 431 syscall( BOTLIB_EA_MOVE_LEFT, client ); 432 } 433 434 void trap_EA_MoveRight(int client) { 435 syscall( BOTLIB_EA_MOVE_RIGHT, client ); 436 } 437 438 void trap_EA_SelectWeapon(int client, int weapon) { 439 syscall( BOTLIB_EA_SELECT_WEAPON, client, weapon ); 440 } 441 442 void trap_EA_Jump(int client) { 443 syscall( BOTLIB_EA_JUMP, client ); 444 } 445 446 void trap_EA_DelayedJump(int client) { 447 syscall( BOTLIB_EA_DELAYED_JUMP, client ); 448 } 449 450 void trap_EA_Move(int client, vec3_t dir, float speed) { 451 syscall( BOTLIB_EA_MOVE, client, dir, PASSFLOAT(speed) ); 452 } 453 454 void trap_EA_View(int client, vec3_t viewangles) { 455 syscall( BOTLIB_EA_VIEW, client, viewangles ); 456 } 457 458 void trap_EA_EndRegular(int client, float thinktime) { 459 syscall( BOTLIB_EA_END_REGULAR, client, PASSFLOAT(thinktime) ); 460 } 461 462 void trap_EA_GetInput(int client, float thinktime, void /* struct bot_input_s */ *input) { 463 syscall( BOTLIB_EA_GET_INPUT, client, PASSFLOAT(thinktime), input ); 464 } 465 466 void trap_EA_ResetInput(int client) { 467 syscall( BOTLIB_EA_RESET_INPUT, client ); 468 } 469 470 int trap_BotLoadCharacter(char *charfile, float skill) { 471 return syscall( BOTLIB_AI_LOAD_CHARACTER, charfile, PASSFLOAT(skill)); 472 } 473 474 void trap_BotFreeCharacter(int character) { 475 syscall( BOTLIB_AI_FREE_CHARACTER, character ); 476 } 477 478 float trap_Characteristic_Float(int character, int index) { 479 int temp; 480 temp = syscall( BOTLIB_AI_CHARACTERISTIC_FLOAT, character, index ); 481 return (*(float*)&temp); 482 } 483 484 float trap_Characteristic_BFloat(int character, int index, float min, float max) { 485 int temp; 486 temp = syscall( BOTLIB_AI_CHARACTERISTIC_BFLOAT, character, index, PASSFLOAT(min), PASSFLOAT(max) ); 487 return (*(float*)&temp); 488 } 489 490 int trap_Characteristic_Integer(int character, int index) { 491 return syscall( BOTLIB_AI_CHARACTERISTIC_INTEGER, character, index ); 492 } 493 494 int trap_Characteristic_BInteger(int character, int index, int min, int max) { 495 return syscall( BOTLIB_AI_CHARACTERISTIC_BINTEGER, character, index, min, max ); 496 } 497 498 void trap_Characteristic_String(int character, int index, char *buf, int size) { 499 syscall( BOTLIB_AI_CHARACTERISTIC_STRING, character, index, buf, size ); 500 } 501 502 int trap_BotAllocChatState(void) { 503 return syscall( BOTLIB_AI_ALLOC_CHAT_STATE ); 504 } 505 506 void trap_BotFreeChatState(int handle) { 507 syscall( BOTLIB_AI_FREE_CHAT_STATE, handle ); 508 } 509 510 void trap_BotQueueConsoleMessage(int chatstate, int type, char *message) { 511 syscall( BOTLIB_AI_QUEUE_CONSOLE_MESSAGE, chatstate, type, message ); 512 } 513 514 void trap_BotRemoveConsoleMessage(int chatstate, int handle) { 515 syscall( BOTLIB_AI_REMOVE_CONSOLE_MESSAGE, chatstate, handle ); 516 } 517 518 int trap_BotNextConsoleMessage(int chatstate, void /* struct bot_consolemessage_s */ *cm) { 519 return syscall( BOTLIB_AI_NEXT_CONSOLE_MESSAGE, chatstate, cm ); 520 } 521 522 int trap_BotNumConsoleMessages(int chatstate) { 523 return syscall( BOTLIB_AI_NUM_CONSOLE_MESSAGE, chatstate ); 524 } 525 526 void trap_BotInitialChat(int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 ) { 527 syscall( BOTLIB_AI_INITIAL_CHAT, chatstate, type, mcontext, var0, var1, var2, var3, var4, var5, var6, var7 ); 528 } 529 530 int trap_BotNumInitialChats(int chatstate, char *type) { 531 return syscall( BOTLIB_AI_NUM_INITIAL_CHATS, chatstate, type ); 532 } 533 534 int trap_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 ) { 535 return syscall( BOTLIB_AI_REPLY_CHAT, chatstate, message, mcontext, vcontext, var0, var1, var2, var3, var4, var5, var6, var7 ); 536 } 537 538 int trap_BotChatLength(int chatstate) { 539 return syscall( BOTLIB_AI_CHAT_LENGTH, chatstate ); 540 } 541 542 void trap_BotEnterChat(int chatstate, int client, int sendto) { 543 syscall( BOTLIB_AI_ENTER_CHAT, chatstate, client, sendto ); 544 } 545 546 void trap_BotGetChatMessage(int chatstate, char *buf, int size) { 547 syscall( BOTLIB_AI_GET_CHAT_MESSAGE, chatstate, buf, size); 548 } 549 550 int trap_StringContains(char *str1, char *str2, int casesensitive) { 551 return syscall( BOTLIB_AI_STRING_CONTAINS, str1, str2, casesensitive ); 552 } 553 554 int trap_BotFindMatch(char *str, void /* struct bot_match_s */ *match, unsigned long int context) { 555 return syscall( BOTLIB_AI_FIND_MATCH, str, match, context ); 556 } 557 558 void trap_BotMatchVariable(void /* struct bot_match_s */ *match, int variable, char *buf, int size) { 559 syscall( BOTLIB_AI_MATCH_VARIABLE, match, variable, buf, size ); 560 } 561 562 void trap_UnifyWhiteSpaces(char *string) { 563 syscall( BOTLIB_AI_UNIFY_WHITE_SPACES, string ); 564 } 565 566 void trap_BotReplaceSynonyms(char *string, unsigned long int context) { 567 syscall( BOTLIB_AI_REPLACE_SYNONYMS, string, context ); 568 } 569 570 int trap_BotLoadChatFile(int chatstate, char *chatfile, char *chatname) { 571 return syscall( BOTLIB_AI_LOAD_CHAT_FILE, chatstate, chatfile, chatname ); 572 } 573 574 void trap_BotSetChatGender(int chatstate, int gender) { 575 syscall( BOTLIB_AI_SET_CHAT_GENDER, chatstate, gender ); 576 } 577 578 void trap_BotSetChatName(int chatstate, char *name, int client) { 579 syscall( BOTLIB_AI_SET_CHAT_NAME, chatstate, name, client ); 580 } 581 582 void trap_BotResetGoalState(int goalstate) { 583 syscall( BOTLIB_AI_RESET_GOAL_STATE, goalstate ); 584 } 585 586 void trap_BotResetAvoidGoals(int goalstate) { 587 syscall( BOTLIB_AI_RESET_AVOID_GOALS, goalstate ); 588 } 589 590 void trap_BotRemoveFromAvoidGoals(int goalstate, int number) { 591 syscall( BOTLIB_AI_REMOVE_FROM_AVOID_GOALS, goalstate, number); 592 } 593 594 void trap_BotPushGoal(int goalstate, void /* struct bot_goal_s */ *goal) { 595 syscall( BOTLIB_AI_PUSH_GOAL, goalstate, goal ); 596 } 597 598 void trap_BotPopGoal(int goalstate) { 599 syscall( BOTLIB_AI_POP_GOAL, goalstate ); 600 } 601 602 void trap_BotEmptyGoalStack(int goalstate) { 603 syscall( BOTLIB_AI_EMPTY_GOAL_STACK, goalstate ); 604 } 605 606 void trap_BotDumpAvoidGoals(int goalstate) { 607 syscall( BOTLIB_AI_DUMP_AVOID_GOALS, goalstate ); 608 } 609 610 void trap_BotDumpGoalStack(int goalstate) { 611 syscall( BOTLIB_AI_DUMP_GOAL_STACK, goalstate ); 612 } 613 614 void trap_BotGoalName(int number, char *name, int size) { 615 syscall( BOTLIB_AI_GOAL_NAME, number, name, size ); 616 } 617 618 int trap_BotGetTopGoal(int goalstate, void /* struct bot_goal_s */ *goal) { 619 return syscall( BOTLIB_AI_GET_TOP_GOAL, goalstate, goal ); 620 } 621 622 int trap_BotGetSecondGoal(int goalstate, void /* struct bot_goal_s */ *goal) { 623 return syscall( BOTLIB_AI_GET_SECOND_GOAL, goalstate, goal ); 624 } 625 626 int trap_BotChooseLTGItem(int goalstate, vec3_t origin, int *inventory, int travelflags) { 627 return syscall( BOTLIB_AI_CHOOSE_LTG_ITEM, goalstate, origin, inventory, travelflags ); 628 } 629 630 int trap_BotChooseNBGItem(int goalstate, vec3_t origin, int *inventory, int travelflags, void /* struct bot_goal_s */ *ltg, float maxtime) { 631 return syscall( BOTLIB_AI_CHOOSE_NBG_ITEM, goalstate, origin, inventory, travelflags, ltg, PASSFLOAT(maxtime) ); 632 } 633 634 int trap_BotTouchingGoal(vec3_t origin, void /* struct bot_goal_s */ *goal) { 635 return syscall( BOTLIB_AI_TOUCHING_GOAL, origin, goal ); 636 } 637 638 int trap_BotItemGoalInVisButNotVisible(int viewer, vec3_t eye, vec3_t viewangles, void /* struct bot_goal_s */ *goal) { 639 return syscall( BOTLIB_AI_ITEM_GOAL_IN_VIS_BUT_NOT_VISIBLE, viewer, eye, viewangles, goal ); 640 } 641 642 int trap_BotGetLevelItemGoal(int index, char *classname, void /* struct bot_goal_s */ *goal) { 643 return syscall( BOTLIB_AI_GET_LEVEL_ITEM_GOAL, index, classname, goal ); 644 } 645 646 int trap_BotGetNextCampSpotGoal(int num, void /* struct bot_goal_s */ *goal) { 647 return syscall( BOTLIB_AI_GET_NEXT_CAMP_SPOT_GOAL, num, goal ); 648 } 649 650 int trap_BotGetMapLocationGoal(char *name, void /* struct bot_goal_s */ *goal) { 651 return syscall( BOTLIB_AI_GET_MAP_LOCATION_GOAL, name, goal ); 652 } 653 654 float trap_BotAvoidGoalTime(int goalstate, int number) { 655 int temp; 656 temp = syscall( BOTLIB_AI_AVOID_GOAL_TIME, goalstate, number ); 657 return (*(float*)&temp); 658 } 659 660 void trap_BotSetAvoidGoalTime(int goalstate, int number, float avoidtime) { 661 syscall( BOTLIB_AI_SET_AVOID_GOAL_TIME, goalstate, number, PASSFLOAT(avoidtime)); 662 } 663 664 void trap_BotInitLevelItems(void) { 665 syscall( BOTLIB_AI_INIT_LEVEL_ITEMS ); 666 } 667 668 void trap_BotUpdateEntityItems(void) { 669 syscall( BOTLIB_AI_UPDATE_ENTITY_ITEMS ); 670 } 671 672 int trap_BotLoadItemWeights(int goalstate, char *filename) { 673 return syscall( BOTLIB_AI_LOAD_ITEM_WEIGHTS, goalstate, filename ); 674 } 675 676 void trap_BotFreeItemWeights(int goalstate) { 677 syscall( BOTLIB_AI_FREE_ITEM_WEIGHTS, goalstate ); 678 } 679 680 void trap_BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child) { 681 syscall( BOTLIB_AI_INTERBREED_GOAL_FUZZY_LOGIC, parent1, parent2, child ); 682 } 683 684 void trap_BotSaveGoalFuzzyLogic(int goalstate, char *filename) { 685 syscall( BOTLIB_AI_SAVE_GOAL_FUZZY_LOGIC, goalstate, filename ); 686 } 687 688 void trap_BotMutateGoalFuzzyLogic(int goalstate, float range) { 689 syscall( BOTLIB_AI_MUTATE_GOAL_FUZZY_LOGIC, goalstate, range ); 690 } 691 692 int trap_BotAllocGoalState(int state) { 693 return syscall( BOTLIB_AI_ALLOC_GOAL_STATE, state ); 694 } 695 696 void trap_BotFreeGoalState(int handle) { 697 syscall( BOTLIB_AI_FREE_GOAL_STATE, handle ); 698 } 699 700 void trap_BotResetMoveState(int movestate) { 701 syscall( BOTLIB_AI_RESET_MOVE_STATE, movestate ); 702 } 703 704 void trap_BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type) { 705 syscall( BOTLIB_AI_ADD_AVOID_SPOT, movestate, origin, PASSFLOAT(radius), type); 706 } 707 708 void trap_BotMoveToGoal(void /* struct bot_moveresult_s */ *result, int movestate, void /* struct bot_goal_s */ *goal, int travelflags) { 709 syscall( BOTLIB_AI_MOVE_TO_GOAL, result, movestate, goal, travelflags ); 710 } 711 712 int trap_BotMoveInDirection(int movestate, vec3_t dir, float speed, int type) { 713 return syscall( BOTLIB_AI_MOVE_IN_DIRECTION, movestate, dir, PASSFLOAT(speed), type ); 714 } 715 716 void trap_BotResetAvoidReach(int movestate) { 717 syscall( BOTLIB_AI_RESET_AVOID_REACH, movestate ); 718 } 719 720 void trap_BotResetLastAvoidReach(int movestate) { 721 syscall( BOTLIB_AI_RESET_LAST_AVOID_REACH,movestate ); 722 } 723 724 int trap_BotReachabilityArea(vec3_t origin, int testground) { 725 return syscall( BOTLIB_AI_REACHABILITY_AREA, origin, testground ); 726 } 727 728 int trap_BotMovementViewTarget(int movestate, void /* struct bot_goal_s */ *goal, int travelflags, float lookahead, vec3_t target) { 729 return syscall( BOTLIB_AI_MOVEMENT_VIEW_TARGET, movestate, goal, travelflags, PASSFLOAT(lookahead), target ); 730 } 731 732 int trap_BotPredictVisiblePosition(vec3_t origin, int areanum, void /* struct bot_goal_s */ *goal, int travelflags, vec3_t target) { 733 return syscall( BOTLIB_AI_PREDICT_VISIBLE_POSITION, origin, areanum, goal, travelflags, target ); 734 } 735 736 int trap_BotAllocMoveState(void) { 737 return syscall( BOTLIB_AI_ALLOC_MOVE_STATE ); 738 } 739 740 void trap_BotFreeMoveState(int handle) { 741 syscall( BOTLIB_AI_FREE_MOVE_STATE, handle ); 742 } 743 744 void trap_BotInitMoveState(int handle, void /* struct bot_initmove_s */ *initmove) { 745 syscall( BOTLIB_AI_INIT_MOVE_STATE, handle, initmove ); 746 } 747 748 int trap_BotChooseBestFightWeapon(int weaponstate, int *inventory) { 749 return syscall( BOTLIB_AI_CHOOSE_BEST_FIGHT_WEAPON, weaponstate, inventory ); 750 } 751 752 void trap_BotGetWeaponInfo(int weaponstate, int weapon, void /* struct weaponinfo_s */ *weaponinfo) { 753 syscall( BOTLIB_AI_GET_WEAPON_INFO, weaponstate, weapon, weaponinfo ); 754 } 755 756 int trap_BotLoadWeaponWeights(int weaponstate, char *filename) { 757 return syscall( BOTLIB_AI_LOAD_WEAPON_WEIGHTS, weaponstate, filename ); 758 } 759 760 int trap_BotAllocWeaponState(void) { 761 return syscall( BOTLIB_AI_ALLOC_WEAPON_STATE ); 762 } 763 764 void trap_BotFreeWeaponState(int weaponstate) { 765 syscall( BOTLIB_AI_FREE_WEAPON_STATE, weaponstate ); 766 } 767 768 void trap_BotResetWeaponState(int weaponstate) { 769 syscall( BOTLIB_AI_RESET_WEAPON_STATE, weaponstate ); 770 } 771 772 int trap_GeneticParentsAndChildSelection(int numranks, float *ranks, int *parent1, int *parent2, int *child) { 773 return syscall( BOTLIB_AI_GENETIC_PARENTS_AND_CHILD_SELECTION, numranks, ranks, parent1, parent2, child ); 774 } 775 776 int trap_PC_LoadSource( const char *filename ) { 777 return syscall( BOTLIB_PC_LOAD_SOURCE, filename ); 778 } 779 780 int trap_PC_FreeSource( int handle ) { 781 return syscall( BOTLIB_PC_FREE_SOURCE, handle ); 782 } 783 784 int trap_PC_ReadToken( int handle, pc_token_t *pc_token ) { 785 return syscall( BOTLIB_PC_READ_TOKEN, handle, pc_token ); 786 } 787 788 int trap_PC_SourceFileAndLine( int handle, char *filename, int *line ) { 789 return syscall( BOTLIB_PC_SOURCE_FILE_AND_LINE, handle, filename, line ); 790 }