JKA: MP Source

00099 {
00100         HL_NONE = 0,
00101         HL_FOOT_RT,
00102         HL_FOOT_LT,
00103         HL_LEG_RT,
00104         HL_LEG_LT,
00105         HL_WAIST,
00106         HL_BACK_RT,
00107         HL_BACK_LT,
00108         HL_BACK,
00109         HL_CHEST_RT,
00110         HL_CHEST_LT,
00111         HL_CHEST,
00112         HL_ARM_RT,
00113         HL_ARM_LT,
00114         HL_HAND_RT,
00115         HL_HAND_LT,
00116         HL_HEAD,
00117         HL_GENERIC1,
00118         HL_GENERIC2,
00119         HL_GENERIC3,
00120         HL_GENERIC4,
00121         HL_GENERIC5,
00122         HL_GENERIC6,
00123         HL_MAX
00124 };

00366              {
00367         CON_DISCONNECTED,
00368         CON_CONNECTING,
00369         CON_CONNECTED
00370 };

00778 {
00779         AEL_MINOR,                      //Enemy responds to the sound, but only by looking
00780         AEL_SUSPICIOUS,         //Enemy looks at the sound, and will also investigate it
00781         AEL_DISCOVERED,         //Enemy knows the player is around, and will actively hunt
00782         AEL_DANGER,                     //Enemy should try to find cover
00783         AEL_DANGER_GREAT,       //Enemy should run like hell!
00784 } alertEventLevel_e;

00772 {
00773         AET_SIGHT,
00774         AET_SOUND,
00775 } alertEventType_e;

00089              {
00090         MOVER_POS1,
00091         MOVER_POS2,
00092         MOVER_1TO2,
00093         MOVER_2TO1
00094 } moverState_t;

00380              {
00381         TEAM_BEGIN,             // Beginning a team game, spawn at base
00382         TEAM_ACTIVE             // Now actively playing
00383 } playerTeamStateState_t;

02119 {
02120         if ( ent->client->ps.ammo[weapon] < ammoData[weapon].max )
02121         {
02122                 ent->client->ps.ammo[weapon] += count;
02123                 if ( ent->client->ps.ammo[weapon] > ammoData[weapon].max )
02124                 {
02125                         ent->client->ps.ammo[weapon] = ammoData[weapon].max;
02126                 }
02127         }
02128 }

00020                                                                               {
00021         int i;
00022 
00023         for (i = 0; i < remapCount; i++) {
00024                 if (Q_stricmp(oldShader, remappedShaders[i].oldShader) == 0) {
00025                         // found it, just update this one
00026                         strcpy(remappedShaders[i].newShader,newShader);
00027                         remappedShaders[i].timeOffset = timeOffset;
00028                         return;
00029                 }
00030         }
00031         if (remapCount < MAX_SHADER_REMAPS) {
00032                 strcpy(remappedShaders[remapCount].newShader,newShader);
00033                 strcpy(remappedShaders[remapCount].oldShader,oldShader);
00034                 remappedShaders[remapCount].timeOffset = timeOffset;
00035                 remapCount++;
00036         }
00037 }

00437 {
00438         /*
00439         if (g_gametype.integer == GT_SIEGE)
00440         { //no scoring in this gametype at all.
00441                 return;
00442         }
00443         */
00444 
00445         if ( !ent->client ) {
00446                 return;
00447         }
00448         // no scoring during pre-match warmup
00449         if ( level.warmupTime ) {
00450                 return;
00451         }
00452         // show score plum
00453         //ScorePlum(ent, origin, score);
00454         //
00455         ent->client->ps.persistant[PERS_SCORE] += score;
00456         if ( g_gametype.integer == GT_TEAM && !g_dontPenalizeTeam )
00457                 level.teamScores[ ent->client->ps.persistant[PERS_TEAM] ] += score;
00458         CalculateRanks();
00459 }

00624 {
00625         //FIXME: Handle this in another manner?
00626         if ( level.numAlertEvents >= MAX_ALERT_EVENTS )
00627         {
00628                 if ( !RemoveOldestAlert() )
00629                 {//how could that fail?
00630                         return;
00631                 }
00632         }
00633 
00634         if ( owner == NULL && alertLevel < AEL_DANGER ) //allows un-owned danger alerts
00635                 return;
00636 
00637         //FIXME: if owner is not a player or player ally, and there are no player allies present,
00638         //                      perhaps we don't need to store the alert... unless we want the player to
00639         //                      react to enemy alert events in some way?
00640 
00641         VectorCopy( position, level.alertEvents[ level.numAlertEvents ].position );
00642 
00643         level.alertEvents[ level.numAlertEvents ].radius        = radius;
00644         level.alertEvents[ level.numAlertEvents ].level         = alertLevel;
00645         level.alertEvents[ level.numAlertEvents ].type          = AET_SIGHT;
00646         level.alertEvents[ level.numAlertEvents ].owner         = owner;                
00647         level.alertEvents[ level.numAlertEvents ].addLight      = addLight;     //will get added to actual light at that point when it's checked
00648         level.alertEvents[ level.numAlertEvents ].ID            = level.curAlertID++;
00649         level.alertEvents[ level.numAlertEvents ].timestamp     = level.time;
00650 
00651         level.numAlertEvents++;
00652 }

00580 {
00581         //FIXME: Handle this in another manner?
00582         if ( level.numAlertEvents >= MAX_ALERT_EVENTS )
00583         {
00584                 if ( !RemoveOldestAlert() )
00585                 {//how could that fail?
00586                         return;
00587                 }
00588         }
00589         
00590         if ( owner == NULL && alertLevel < AEL_DANGER ) //allows un-owned danger alerts
00591                 return;
00592 
00593         //FIXME: if owner is not a player or player ally, and there are no player allies present,
00594         //                      perhaps we don't need to store the alert... unless we want the player to
00595         //                      react to enemy alert events in some way?
00596 
00597         VectorCopy( position, level.alertEvents[ level.numAlertEvents ].position );
00598 
00599         level.alertEvents[ level.numAlertEvents ].radius        = radius;
00600         level.alertEvents[ level.numAlertEvents ].level         = alertLevel;
00601         level.alertEvents[ level.numAlertEvents ].type          = AET_SOUND;
00602         level.alertEvents[ level.numAlertEvents ].owner         = owner;
00603         if ( needLOS )
00604         {//a very low-level sound, when check this sound event, check for LOS
00605                 level.alertEvents[ level.numAlertEvents ].addLight      = 1;    //will force an LOS trace on this sound
00606         }
00607         else
00608         {
00609                 level.alertEvents[ level.numAlertEvents ].addLight      = 0;    //will force an LOS trace on this sound
00610         }
00611         level.alertEvents[ level.numAlertEvents ].ID            = level.curAlertID++;
00612         level.alertEvents[ level.numAlertEvents ].timestamp     = level.time;
00613 
00614         level.numAlertEvents++;
00615 }

00143 {
00144 #ifdef BOT_ZMALLOC
00145         int i = 0;
00146 
00147         while (i < MAX_BALLOC)
00148         {
00149                 if (BAllocList[i])
00150                 {
00151                         trap_BotFreeMemoryGame(BAllocList[i]);
00152                         BAllocList[i] = NULL;
00153                 }
00154 
00155                 i++;
00156         }
00157 #endif
00158 }

00134 {
00135 #ifdef BOT_ZMALLOC
00136         memset(BAllocList, 0, sizeof(BAllocList));
00137 #endif
00138 
00139         memset(gWPArray, 0, sizeof(gWPArray));
00140 }

02019                                {
02020         int                     i;
02021         gentity_t       *client;
02022 
02023         if ( level.intermissiontime ) {
02024                 return;         // already active
02025         }
02026 
02027         // if in tournement mode, change the wins / losses
02028         if ( g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL ) {
02029                 trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" );
02030 
02031                 if (g_gametype.integer != GT_POWERDUEL)
02032                 {
02033                         AdjustTournamentScores();
02034                 }
02035                 if (DuelLimitHit())
02036                 {
02037                         gDuelExit = qtrue;
02038                 }
02039                 else
02040                 {
02041                         gDuelExit = qfalse;
02042                 }
02043         }
02044 
02045         level.intermissiontime = level.time;
02046         FindIntermissionPoint();
02047 
02048         /*
02049         if (g_singlePlayer.integer) {
02050                 trap_Cvar_Set("ui_singlePlayerActive", "0");
02051                 UpdateTournamentInfo();
02052         }
02053         */
02054         //what the? Well, I don't want this to happen.
02055 
02056         // move all clients to the intermission point
02057         for (i=0 ; i< level.maxclients ; i++) {
02058                 client = g_entities + i;
02059                 if (!client->inuse)
02060                         continue;
02061                 // respawn if dead
02062                 if (client->health <= 0) {
02063                         if (g_gametype.integer != GT_POWERDUEL ||
02064                                 !client->client ||
02065                                 client->client->sess.sessionTeam != TEAM_SPECTATOR)
02066                         { //don't respawn spectators in powerduel or it will mess the line order all up
02067                                 respawn(client);
02068                         }
02069                 }
02070                 MoveClientToIntermission( client );
02071         }
02072 
02073         // send the current scoring to all clients
02074         SendScoreboardMessageToAllClients();
02075 
02076 }

02850 {
02851         gentity_t *found = NULL;
02852 
02853         if ( ent->client->ps.hasDetPackPlanted )
02854         {
02855                 while ( (found = G_Find( found, FOFS(classname), "detpack") ) != NULL )
02856                 {//loop through all ents and blow the crap out of them!
02857                         if ( found->parent == ent )
02858                         {
02859                                 VectorCopy( found->r.currentOrigin, found->s.origin );
02860                                 found->think = DetPackBlow;
02861                                 found->nextthink = level.time + 100 + random() * 200;
02862                                 G_Sound( found, CHAN_BODY, G_SoundIndex("sound/weapons/detpack/warning.wav") );
02863                         }
02864                 }
02865                 ent->client->ps.hasDetPackPlanted = qfalse;
02866         }
02867 }

00685                                                                                                           {
00686         // NOTENOTE No gibbing right now, this is star wars.
00687         qboolean doDisint = qfalse;
00688 
00689         if (self->s.eType == ET_NPC)
00690         { //well, just rem it then, so long as it's done with its death anim and it's not a standard weapon.
00691                 if ( self->client && self->client->ps.torsoTimer <= 0 &&
00692                          (meansOfDeath == MOD_UNKNOWN ||
00693                           meansOfDeath == MOD_WATER ||
00694                           meansOfDeath == MOD_SLIME ||
00695                           meansOfDeath == MOD_LAVA ||
00696                           meansOfDeath == MOD_CRUSH ||
00697                           meansOfDeath == MOD_TELEFRAG ||
00698                           meansOfDeath == MOD_FALLING ||
00699                           meansOfDeath == MOD_SUICIDE ||
00700                           meansOfDeath == MOD_TARGET_LASER ||
00701                           meansOfDeath == MOD_TRIGGER_HURT) )
00702                 {
00703                         self->think = G_FreeEntity;
00704                         self->nextthink = level.time;
00705                 }
00706                 return;
00707         }
00708 
00709         if (self->health < (GIB_HEALTH+1))
00710         {
00711                 self->health = GIB_HEALTH+1;
00712 
00713                 if (self->client && (level.time - self->client->respawnTime) < 2000)
00714                 {
00715                         doDisint = qfalse;
00716                 }
00717                 else
00718                 {
00719                         doDisint = qtrue;
00720                 }
00721         }
00722 
00723         if (self->client && (self->client->ps.eFlags & EF_DISINTEGRATION))
00724         {
00725                 return;
00726         }
00727         else if (self->s.eFlags & EF_DISINTEGRATION)
00728         {
00729                 return;
00730         }
00731 
00732         if (doDisint)
00733         {
00734                 if (self->client)
00735                 {
00736                         self->client->ps.eFlags |= EF_DISINTEGRATION;
00737                         VectorCopy(self->client->ps.origin, self->client->ps.lastHitLoc);
00738                 }
00739                 else
00740                 {
00741                         self->s.eFlags |= EF_DISINTEGRATION;
00742                         VectorCopy(self->r.currentOrigin, self->s.origin2);
00743 
00744                         //since it's the corpse entity, tell it to "remove" itself
00745                         self->think = BodyRid;
00746                         self->nextthink = level.time + 1000;
00747                 }
00748                 return;
00749         }
00750 }

00966                                 {
00967         int                     i;
00968 
00969         for (i = 0; i < MAX_CLIENTS; i++) {
00970                 if (botstates[i] && botstates[i]->inuse) {
00971                         BotResetState( botstates[i] );
00972                         botstates[i]->setupcount = 4;
00973                 }
00974         }
00975 
00976         return qtrue;
00977 }

07575                               {
07576         //rww - new bot cvars..
07577         trap_Cvar_Register(&bot_forcepowers, "bot_forcepowers", "1", CVAR_CHEAT);
07578         trap_Cvar_Register(&bot_forgimmick, "bot_forgimmick", "0", CVAR_CHEAT);
07579         trap_Cvar_Register(&bot_honorableduelacceptance, "bot_honorableduelacceptance", "0", CVAR_CHEAT);
07580         trap_Cvar_Register(&bot_pvstype, "bot_pvstype", "1", CVAR_CHEAT);
07581 #ifndef FINAL_BUILD
07582         trap_Cvar_Register(&bot_getinthecarrr, "bot_getinthecarrr", "0", 0);
07583 #endif
07584 
07585 #ifdef _DEBUG
07586         trap_Cvar_Register(&bot_nogoals, "bot_nogoals", "0", CVAR_CHEAT);
07587         trap_Cvar_Register(&bot_debugmessages, "bot_debugmessages", "0", CVAR_CHEAT);
07588 #endif
07589 
07590         trap_Cvar_Register(&bot_attachments, "bot_attachments", "1", 0);
07591         trap_Cvar_Register(&bot_camp, "bot_camp", "1", 0);
07592 
07593         trap_Cvar_Register(&bot_wp_info, "bot_wp_info", "1", 0);
07594         trap_Cvar_Register(&bot_wp_edit, "bot_wp_edit", "0", CVAR_CHEAT);
07595         trap_Cvar_Register(&bot_wp_clearweight, "bot_wp_clearweight", "1", 0);
07596         trap_Cvar_Register(&bot_wp_distconnect, "bot_wp_distconnect", "1", 0);
07597         trap_Cvar_Register(&bot_wp_visconnect, "bot_wp_visconnect", "1", 0);
07598 
07599         trap_Cvar_Update(&bot_forcepowers);
07600         //end rww
07601 
07602         //if the game is restarted for a tournament
07603         if (restart) {
07604                 return qtrue;
07605         }
07606 
07607         //initialize the bot states
07608         memset( botstates, 0, sizeof(botstates) );
07609 
07610         if (!trap_BotLibSetup())
07611         {
07612                 return qfalse; //wts?!
07613         }
07614 
07615         return qtrue;
07616 }

00819                                                                                     {
00820         bot_state_t *bs;
00821 
00822         if (!botstates[client]) botstates[client] = (bot_state_t *) B_Alloc(sizeof(bot_state_t)); //G_Alloc(sizeof(bot_state_t));
00823                                                                                                                                                           //rww - G_Alloc bad! B_Alloc good.
00824 
00825         memset(botstates[client], 0, sizeof(bot_state_t));
00826 
00827         bs = botstates[client];
00828 
00829         if (bs && bs->inuse) {
00830                 BotAI_Print(PRT_FATAL, "BotAISetupClient: client %d already setup\n", client);
00831                 return qfalse;
00832         }
00833 
00834         memcpy(&bs->settings, settings, sizeof(bot_settings_t));
00835 
00836         bs->client = client; //need to know the client number before doing personality stuff
00837 
00838         //initialize weapon weight defaults..
00839         bs->botWeaponWeights[WP_NONE] = 0;
00840         bs->botWeaponWeights[WP_STUN_BATON] = 1;
00841         bs->botWeaponWeights[WP_SABER] = 10;
00842         bs->botWeaponWeights[WP_BRYAR_PISTOL] = 11;
00843         bs->botWeaponWeights[WP_BLASTER] = 12;
00844         bs->botWeaponWeights[WP_DISRUPTOR] = 13;
00845         bs->botWeaponWeights[WP_BOWCASTER] = 14;
00846         bs->botWeaponWeights[WP_REPEATER] = 15;
00847         bs->botWeaponWeights[WP_DEMP2] = 16;
00848         bs->botWeaponWeights[WP_FLECHETTE] = 17;
00849         bs->botWeaponWeights[WP_ROCKET_LAUNCHER] = 18;
00850         bs->botWeaponWeights[WP_THERMAL] = 14;
00851         bs->botWeaponWeights[WP_TRIP_MINE] = 0;
00852         bs->botWeaponWeights[WP_DET_PACK] = 0;
00853         bs->botWeaponWeights[WP_MELEE] = 1;
00854 
00855         BotUtilizePersonality(bs);
00856 
00857         if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
00858         {
00859                 bs->botWeaponWeights[WP_SABER] = 13;
00860         }
00861 
00862         //allocate a goal state
00863         bs->gs = trap_BotAllocGoalState(client);
00864 
00865         //allocate a weapon state
00866         bs->ws = trap_BotAllocWeaponState();
00867 
00868         bs->inuse = qtrue;
00869         bs->entitynum = client;
00870         bs->setupcount = 4;
00871         bs->entergame_time = FloatTime();
00872         bs->ms = trap_BotAllocMoveState();
00873         numbots++;
00874 
00875         //NOTE: reschedule the bot thinking
00876         BotScheduleBotThink();
00877 
00878         if (PlayersInGame())
00879         { //don't talk to yourself
00880                 BotDoChat(bs, "GeneralGreetings", 0);
00881         }
00882 
00883         return qtrue;
00884 }

07623                                  {
07624 
07625         int i;
07626 
07627         //if the game is restarted for a tournament
07628         if ( restart ) {
07629                 //shutdown all the bots in the botlib
07630                 for (i = 0; i < MAX_CLIENTS; i++) {
07631                         if (botstates[i] && botstates[i]->inuse) {
07632                                 BotAIShutdownClient(botstates[i]->client, restart);
07633                         }
07634                 }
07635                 //don't shutdown the bot library
07636         }
07637         else {
07638                 trap_BotLibShutdown();
07639         }
07640         return qtrue;
07641 }

00891                                                       {
00892         bot_state_t *bs;
00893 
00894         bs = botstates[client];
00895         if (!bs || !bs->inuse) {
00896                 //BotAI_Print(PRT_ERROR, "BotAIShutdownClient: client %d already shutdown\n", client);
00897                 return qfalse;
00898         }
00899 
00900         trap_BotFreeMoveState(bs->ms);
00901         //free the goal state`                  
00902         trap_BotFreeGoalState(bs->gs);
00903         //free the weapon weights
00904         trap_BotFreeWeaponState(bs->ws);
00905         //
00906         //clear the bot state
00907         memset(bs, 0, sizeof(bot_state_t));
00908         //set the inuse flag to qfalse
00909         bs->inuse = qfalse;
00910         //there's one bot less
00911         numbots--;
00912         //everything went ok
00913         return qtrue;
00914 }

07492                               {
07493         int i;
07494         int elapsed_time, thinktime;
07495         static int local_time;
07496         static int botlib_residual;
07497         static int lastbotthink_time;
07498 
07499         if (gUpdateVars < level.time)
07500         {
07501                 trap_Cvar_Update(&bot_pvstype);
07502                 trap_Cvar_Update(&bot_camp);
07503                 trap_Cvar_Update(&bot_attachments);
07504                 trap_Cvar_Update(&bot_forgimmick);
07505                 trap_Cvar_Update(&bot_honorableduelacceptance);
07506 #ifndef FINAL_BUILD
07507                 trap_Cvar_Update(&bot_getinthecarrr);
07508 #endif
07509                 gUpdateVars = level.time + 1000;
07510         }
07511 
07512         G_CheckBotSpawn();
07513 
07514         //rww - addl bot frame functions
07515         if (gBotEdit)
07516         {
07517                 trap_Cvar_Update(&bot_wp_info);
07518                 BotWaypointRender();
07519         }
07520 
07521         UpdateEventTracker();
07522         //end rww
07523 
07524         //cap the bot think time
07525         //if the bot think time changed we should reschedule the bots
07526         if (BOT_THINK_TIME != lastbotthink_time) {
07527                 lastbotthink_time = BOT_THINK_TIME;
07528                 BotScheduleBotThink();
07529         }
07530 
07531         elapsed_time = time - local_time;
07532         local_time = time;
07533 
07534         if (elapsed_time > BOT_THINK_TIME) thinktime = elapsed_time;
07535         else thinktime = BOT_THINK_TIME;
07536 
07537         // execute scheduled bot AI
07538         for( i = 0; i < MAX_CLIENTS; i++ ) {
07539                 if( !botstates[i] || !botstates[i]->inuse ) {
07540                         continue;
07541                 }
07542                 //
07543                 botstates[i]->botthink_residual += elapsed_time;
07544                 //
07545                 if ( botstates[i]->botthink_residual >= thinktime ) {
07546                         botstates[i]->botthink_residual -= thinktime;
07547 
07548                         if (g_entities[i].client->pers.connected == CON_CONNECTED) {
07549                                 BotAI(i, (float) thinktime / 1000);
07550                         }
07551                 }
07552         }
07553 
07554         // execute bot user commands every frame
07555         for( i = 0; i < MAX_CLIENTS; i++ ) {
07556                 if( !botstates[i] || !botstates[i]->inuse ) {
07557                         continue;
07558                 }
07559                 if( g_entities[i].client->pers.connected != CON_CONNECTED ) {
07560                         continue;
07561                 }
07562 
07563                 BotUpdateInput(botstates[i], time, elapsed_time);
07564                 trap_BotUserCommand(botstates[i]->client, &botstates[i]->lastucmd);
07565         }
07566 
07567         return qtrue;
07568 }

00185 {
00186         int stateMin = 0;
00187         int stateMax = 0;
00188         int i = 0;
00189 
00190         if (!ent || !ent->client || !ent->client->sess.teamLeader)
00191         {
00192                 return;
00193         }
00194 
00195         if (clientnum != -1 && !botstates[clientnum])
00196         {
00197                 return;
00198         }
00199 
00200         if (clientnum != -1 && !OnSameTeam(ent, &g_entities[clientnum]))
00201         {
00202                 return;
00203         }
00204 
00205         if (g_gametype.integer != GT_CTF && g_gametype.integer != GT_CTY && g_gametype.integer != GT_SIEGE &&
00206                 g_gametype.integer != GT_TEAM)
00207         {
00208                 return;
00209         }
00210 
00211         if (g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY)
00212         {
00213                 stateMin = CTFSTATE_NONE;
00214                 stateMax = CTFSTATE_MAXCTFSTATES;
00215         }
00216         else if (g_gametype.integer == GT_SIEGE)
00217         {
00218                 stateMin = SIEGESTATE_NONE;
00219                 stateMax = SIEGESTATE_MAXSIEGESTATES;
00220         }
00221         else if (g_gametype.integer == GT_TEAM)
00222         {
00223                 stateMin = TEAMPLAYSTATE_NONE;
00224                 stateMax = TEAMPLAYSTATE_MAXTPSTATES;
00225         }
00226 
00227         if ((ordernum < stateMin && ordernum != -1) || ordernum >= stateMax)
00228         {
00229                 return;
00230         }
00231 
00232         if (clientnum != -1)
00233         {
00234                 if (ordernum == -1)
00235                 {
00236                         BotReportStatus(botstates[clientnum]);
00237                 }
00238                 else
00239                 {
00240                         BotStraightTPOrderCheck(ent, ordernum, botstates[clientnum]);
00241                         botstates[clientnum]->state_Forced = ordernum;
00242                         botstates[clientnum]->chatObject = ent;
00243                         botstates[clientnum]->chatAltObject = NULL;
00244                         if (BotDoChat(botstates[clientnum], "OrderAccepted", 1))
00245                         {
00246                                 botstates[clientnum]->chatTeam = 1;
00247                         }
00248                 }
00249         }
00250         else
00251         {
00252                 while (i < MAX_CLIENTS)
00253                 {
00254                         if (botstates[i] && OnSameTeam(ent, &g_entities[i]))
00255                         {
00256                                 if (ordernum == -1)
00257                                 {
00258                                         BotReportStatus(botstates[i]);
00259                                 }
00260                                 else
00261                                 {
00262                                         BotStraightTPOrderCheck(ent, ordernum, botstates[i]);
00263                                         botstates[i]->state_Forced = ordernum;
00264                                         botstates[i]->chatObject = ent;
00265                                         botstates[i]->chatAltObject = NULL;
00266                                         if (BotDoChat(botstates[i], "OrderAccepted", 0))
00267                                         {
00268                                                 botstates[i]->chatTeam = 1;
00269                                         }
00270                                 }
00271                         }
00272 
00273                         i++;
00274                 }
00275         }
00276 }

codemp/game/g_local.h File Reference

Data Structures

Defines

Typedefs

Enumerations

Functions

Variables

Define Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation


Data Structures
struct	alertEvent_s
struct	bot_settings_s
struct	clientPersistant_t
struct	clientSession_t
struct	combatPoint_t
struct	gclient_s
struct	gentity_s
struct	interestPoint_t
struct	level_locals_t
struct	playerTeamState_t
struct	reference_tag_s
struct	renderInfo_s
struct	waypointData_t
Defines
#define	GAME_INLINE ID_INLINE
#define	GAMEVERSION "basejka_mod"
#define	BODY_QUEUE_SIZE 8
#define	INFINITE 1000000
#define	FRAMETIME 100
#define	CARNAGE_REWARD_TIME 3000
#define	REWARD_SPRITE_TIME 2000
#define	INTERMISSION_DELAY_TIME 1000
#define	SP_INTERMISSION_DELAY_TIME 5000
#define	START_TIME_LINK_ENTS FRAMETIME*1
#define	START_TIME_FIND_LINKS FRAMETIME*2
#define	START_TIME_MOVERS_SPAWNED FRAMETIME*2
#define	START_TIME_REMOVE_ENTS FRAMETIME*3
#define	START_TIME_NAV_CALC FRAMETIME*4
#define	START_TIME_FIND_WAYPOINT FRAMETIME*5
#define	FL_GODMODE 0x00000010
#define	FL_NOTARGET 0x00000020
#define	FL_TEAMSLAVE 0x00000400
#define	FL_NO_KNOCKBACK 0x00000800
#define	FL_DROPPED_ITEM 0x00001000
#define	FL_NO_BOTS 0x00002000
#define	FL_NO_HUMANS 0x00004000
#define	FL_FORCE_GESTURE 0x00008000
#define	FL_INACTIVE 0x00010000