ubergames/lilium-voyager
0
0
Fork 0
mirror of https://github.com/UberGames/lilium-voyager.git synced 2024-12-13 13:40:56 +00:00
Code Issues Projects Releases Packages Wiki Activity
lilium-voyager/code/game/ai_team.c
Thilo Schulz eb9fe030c4 Batch of bug fixes for gamecode. Patch compiled and log message written by Tobias Kuehnhammer (#5144) 
################################################################################
This Patch fixes:
################################################################################

- The "fraglimit warning" was not played at all, if on the blue team.
- The "where" console command was broken.
- Obelisk explosion wasn't drawn if no Rocketlauncher was loaded.
- Impact marks sometimes didn't draw at all.
- IMPORTANT BUGFIX: No killing for cheaters with Lightning gun and Gauntlet.
- If two doors are close to each other a spectator couldn't fly through them.
- More robust, efficient and logical respawning routine.
  NOTE: The game.qvm will get notable smaller and will use LESS MEMORY!
- Drowning sounds are fixed. Now they are played as intended. (as the id
comment
  in the source code shows).
- Some AI bugs (OVERFLOW!) in the bot movement code.
- Several "Team Arena" Overload and Harvester bugs.
- Stops bots from attacking a team mate (player) who only changed teams.
- Some voice chats and CTF commands fixed.
- "Team_ReturnFlag" was called twice, which did wired things sometimes. 
  NOTE: (G_RunItem checks CONTENTS_NODROP already!)
- A bugfix for Gauntlet animation.
- Incorrect CTF scoring.
- A bunch of corrected comments and print lines ("\n").
- Some regularity of expression and some small trivial bugs.

################################################################################
Details:
################################################################################

********************************************************************************
BUG: in gamemode GT_TEAM the fraglimit warning will not be played if joining
the
     blue team!
--------------------------------------------------------------------------------
Solution: In "CG_CheckLocalSounds": if cgs.scores2 > highScore, highScore
should
          be cgs.scores2.
********************************************************************************
BUG: the "where" console command doesn't work as expected (it's always 0 0 0) 
     but not in id Quake 3 Arena. It seems that now Ioquake3 is affected!
--------------------------------------------------------------------------------
Solution: In Function "Cmd_Where_f" ent->s.origin should be 
          ent->r.currentOrigin.
********************************************************************************
BUG: in gamemode GT_OBELISK obelisk explosion won't be drawn if there is no 
     Rocketlauncher loaded. (The "maps without Rocketlauncher" bug)
--------------------------------------------------------------------------------
Solution: in "cg_main.c": cgs.media.rocketExplosionShader should be registered 
          if gamemode is GT_OBELISK.
********************************************************************************
BUG: Impact marks sometimes doesn't draw at all. Not easy to reproduce if you 
     don't play (io)Quake3 every day and know the places where it happens! ;) 
     But anyway...
     Test: start q3dm12 go to "Long Jump Canyon" (where the small platform 
     teleporter for the BFG is) place yourself at the point where the railgun 
     spawns, look in the direction where the red suspended armor is. Now shoot
     at the sloped wall on the out/leftside of the door you see. (the sloped 
     wall should be nearly in the center of your screen now). If you choose the 
     correct brush face and shoot up and down at this brush face, the impact 
     marks sometimes aren't visible.

     There are hundreds of custom maps where this can happen!
--------------------------------------------------------------------------------
Solution: I replaced the function "SnapVectorTowards" with the one from 
         "Wolfenstein - Enemy Territory (GPL Source Code)"
********************************************************************************
BUG: Normally "NOCLIP" cheaters are logically not allowed to fire a gun.
     Unfortunatly the Gauntlet (and Lightning gun) was forgotten and not 
     restricted to that. All weapons except those two were handled correct. 
--------------------------------------------------------------------------------
Solution: Make Gauntlet and Lightning gun not firing for someone who cheats 
          with "NOCLIP" (like all other weapons).
********************************************************************************
NOTE: A few bugfixes are not mine and are reported here: 
      http://www.quake3world.com/forum/viewtopic.php?f=16&t=9179.

      Thanks to Quake3world, for all those years and the good guys there!
********************************************************************************
BUG: During making a mod I found a very strange bug, which mainly occurs if
     someone tries to implement a lot of singleplayer monsters which should
walk
     slowly (like the "Crash" bot). So if someone wants to make slow down bots
     or monsters when they are walking towards a goal and alter the function
     "BotMoveInGoalArea" then the bots/monsters do stupid things. Otherwise and
     this is the default (also buggy) behavior they start running although they
     shouldn't (as seen with the "Crash" bot and will not be fixed here).
--------------------------------------------------------------------------------
Solution: Fix overflow in bot user command. BUGFIX from "Hunt" mod by J. 
          Hoffman.
********************************************************************************
BUG: in function "BotMoveToGoal" the special elevator case doesn't make sense.
--------------------------------------------------------------------------------
Solution: in "be_ai_move.c": ((result->flags & MOVERESULT_ONTOPOF_FUNCBOB) ||
                              (result->flags & MOVERESULT_ONTOPOF_FUNCBOB)) 
                   should be ((result->flags & MOVERESULT_ONTOPOF_ELEVATOR) ||
                              (result->flags & MOVERESULT_ONTOPOF_FUNCBOB)).
********************************************************************************
BUG: in function "BotWantsToRetreat" and "BotWantsToChase" this is wrong:
     "(bs->enemy != redobelisk.entitynum || bs->enemy !=
blueobelisk.entitynum)"
--------------------------------------------------------------------------------
Solution: "... redobelisk.entitynum) && (bs->enemy != blueobelisk.." is
correct.
********************************************************************************
BUG: in gamemode GT_OBELISK there are too many node switches for bots 
     (test: mpq3tourney6 with many bots). If that happens, game becomes 
     unplayable. I don't know if this is the best solution but here it is:
--------------------------------------------------------------------------------
Solution: In function "AINode_Battle_Fight" right after:
if (!BotEntityVisible(bs->entitynum, bs->eye, bs->viewangles, 360, bs->enemy))
{
   I added this: 
#ifdef MISSIONPACK
    if (bs->enemy == redobelisk.entitynum || bs->enemy == 
                                                        blueobelisk.entitynum)
{
    AIEnter_Battle_Chase(bs, "battle fight: obelisk out of sight");
    return qfalse;
    }
#endif
********************************************************************************
BUG: in gamemode >= GT_TEAM, after team change, bots will (sometimes) not stop
     shooting at you, although you are on their team now. It seems that the 
     configstrings are f***** up or not reliable in this case!
--------------------------------------------------------------------------------
Solution: In function "BotTeam" and "BotSameTeam" get the real team values.
********************************************************************************
BUG: Some of the bots voice commands are wrong. They are commanded to attack
the
     enemy base but they say "Okay, I will defend!"
--------------------------------------------------------------------------------
Solution: Corrected some voice commands in "BotCTFOrders_FlagNotAtBase" and
         "Bot1FCTFOrders_EnemyDroppedFlag"
********************************************************************************
BUG: Spectators couldn't fly through doors if they are very close to each
other.
     You can test it with some regular id maps (q3dm14, q3dm12) but there are
     also many custom maps where this can happen! This is annoying because in 
     the worst case you can't move at all and are caught inside a door.
--------------------------------------------------------------------------------
Solution: There is a solution in a mod called "Hunt" by J. Hoffman. 
          Bugfix is included in this patch!
********************************************************************************
BUG: During making a mod I found it very hard to implement some of my ideas
     (something like "Limbo" or "Meeting") because of the way the player spawn
     effect, intermission and spawning on victory pads is handled. I reworked
it
     a bit and simplified it so that the effect is handled when a client      
     respawns
     (as the name says) and not when a client begins. I think this will help 
     more
     mod makers everytime they want to make changes to spawning of players,
bots
     on victory pads or monsters... and want to avoid spectators with 
     Machineguns
     which can kill and score... :()

     NOTE: I also renamed the poorly named function "respawn" 
           to "ClientRespawn". If someone searches the code base for "respawn" 
           it was really hard to find the correct place for what was 
           meant. "respawn" is used so often, that you really get headache ... 
           now with "ClientRespawn" it's easier!

     IMPORTANT: The whole respawning, moving to intermission point and 
                everything related to that is now done in a more reliable way 
                without changing the default behavior. (How critical the whole 
                spwaning mess was did you see by yourself (ioquake3 rev. 2076). 
                With this patch it's safer. 
                Trust me, I spent hours of fixing silly problems...
-------------------------------------------------------------------------------- 
Solution: Simplified "ClientBegin" and moved the teleport event  
          to "ClientSpawn".
********************************************************************************
BUG: If a player is dying or hurted under water the hurt/dying sounds AND the
     drowning sounds are played together. This is silly. Moreover it's no good
     idea to let the server play client sounds! There was a solution in a mod 
     called "Q3A++" by Dan 'Neurobasher' Gomes which fixes the problem.
--------------------------------------------------------------------------------
Solution: Created a "CG_WaterLevel" function to play the appropriate sounds.
********************************************************************************

################################################################################
2011-08-01 11:39:33 +00:00

2080 lines
65 KiB
C
Raw Blame History

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
This file is part of Quake III Arena source code.
Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Quake III Arena source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
//
/*****************************************************************************
* name: ai_team.c
*
* desc: Quake3 bot AI
*
* $Archive: /MissionPack/code/game/ai_team.c $
*
*****************************************************************************/
#include "g_local.h"
#include "../botlib/botlib.h"
#include "../botlib/be_aas.h"
#include "../botlib/be_ea.h"
#include "../botlib/be_ai_char.h"
#include "../botlib/be_ai_chat.h"
#include "../botlib/be_ai_gen.h"
#include "../botlib/be_ai_goal.h"
#include "../botlib/be_ai_move.h"
#include "../botlib/be_ai_weap.h"
//
#include "ai_main.h"
#include "ai_dmq3.h"
#include "ai_chat.h"
#include "ai_cmd.h"
#include "ai_dmnet.h"
#include "ai_team.h"
#include "ai_vcmd.h"
#include "match.h"
// for the voice chats
#include "../../ui/menudef.h"
//ctf task preferences for a client
typedef struct bot_ctftaskpreference_s
{
char name[36];
int preference;
} bot_ctftaskpreference_t;
bot_ctftaskpreference_t ctftaskpreferences[MAX_CLIENTS];
/*
==================
BotValidTeamLeader
==================
*/
int BotValidTeamLeader(bot_state_t *bs) {
if (!strlen(bs->teamleader)) return qfalse;
if (ClientFromName(bs->teamleader) == -1) return qfalse;
return qtrue;
}
/*
==================
BotNumTeamMates
==================
*/
int BotNumTeamMates(bot_state_t *bs) {
int i, numplayers;
char buf[MAX_INFO_STRING];
static int maxclients;
if (!maxclients)
maxclients = trap_Cvar_VariableIntegerValue("sv_maxclients");
numplayers = 0;
for (i = 0; i < maxclients && i < MAX_CLIENTS; i++) {
trap_GetConfigstring(CS_PLAYERS+i, buf, sizeof(buf));
//if no config string or no name
if (!strlen(buf) || !strlen(Info_ValueForKey(buf, "n"))) continue;
//skip spectators
if (atoi(Info_ValueForKey(buf, "t")) == TEAM_SPECTATOR) continue;
//
if (BotSameTeam(bs, i)) {
numplayers++;
}
}
return numplayers;
}
/*
==================
BotClientTravelTimeToGoal
==================
*/
int BotClientTravelTimeToGoal(int client, bot_goal_t *goal) {
playerState_t ps;
int areanum;
BotAI_GetClientState(client, &ps);
areanum = BotPointAreaNum(ps.origin);
if (!areanum) return 1;
return trap_AAS_AreaTravelTimeToGoalArea(areanum, ps.origin, goal->areanum, TFL_DEFAULT);
}
/*
==================
BotSortTeamMatesByBaseTravelTime
==================
*/
int BotSortTeamMatesByBaseTravelTime(bot_state_t *bs, int *teammates, int maxteammates) {
int i, j, k, numteammates, traveltime;
char buf[MAX_INFO_STRING];
static int maxclients;
int traveltimes[MAX_CLIENTS];
bot_goal_t *goal = NULL;
if (gametype == GT_CTF || gametype == GT_1FCTF) {
if (BotTeam(bs) == TEAM_RED)
goal = &ctf_redflag;
else
goal = &ctf_blueflag;
}
#ifdef MISSIONPACK
else {
if (BotTeam(bs) == TEAM_RED)
goal = &redobelisk;
else
goal = &blueobelisk;
}
#endif
if (!maxclients)
maxclients = trap_Cvar_VariableIntegerValue("sv_maxclients");
numteammates = 0;
for (i = 0; i < maxclients && i < MAX_CLIENTS; i++) {
trap_GetConfigstring(CS_PLAYERS+i, buf, sizeof(buf));
//if no config string or no name
if (!strlen(buf) || !strlen(Info_ValueForKey(buf, "n"))) continue;
//skip spectators
if (atoi(Info_ValueForKey(buf, "t")) == TEAM_SPECTATOR) continue;
//
if (BotSameTeam(bs, i)) {
//
traveltime = BotClientTravelTimeToGoal(i, goal);
//
for (j = 0; j < numteammates; j++) {
if (traveltime < traveltimes[j]) {
for (k = numteammates; k > j; k--) {
traveltimes[k] = traveltimes[k-1];
teammates[k] = teammates[k-1];
}
break;
}
}
traveltimes[j] = traveltime;
teammates[j] = i;
numteammates++;
if (numteammates >= maxteammates) break;
}
}
return numteammates;
}
/*
==================
BotSetTeamMateTaskPreference
==================
*/
void BotSetTeamMateTaskPreference(bot_state_t *bs, int teammate, int preference) {
char teammatename[MAX_NETNAME];
ctftaskpreferences[teammate].preference = preference;
ClientName(teammate, teammatename, sizeof(teammatename));
strcpy(ctftaskpreferences[teammate].name, teammatename);
}
/*
==================
BotGetTeamMateTaskPreference
==================
*/
int BotGetTeamMateTaskPreference(bot_state_t *bs, int teammate) {
char teammatename[MAX_NETNAME];
if (!ctftaskpreferences[teammate].preference) return 0;
ClientName(teammate, teammatename, sizeof(teammatename));
if (Q_stricmp(teammatename, ctftaskpreferences[teammate].name)) return 0;
return ctftaskpreferences[teammate].preference;
}
/*
==================
BotSortTeamMatesByTaskPreference
==================
*/
int BotSortTeamMatesByTaskPreference(bot_state_t *bs, int *teammates, int numteammates) {
int defenders[MAX_CLIENTS], numdefenders;
int attackers[MAX_CLIENTS], numattackers;
int roamers[MAX_CLIENTS], numroamers;
int i, preference;
numdefenders = numattackers = numroamers = 0;
for (i = 0; i < numteammates; i++) {
preference = BotGetTeamMateTaskPreference(bs, teammates[i]);
if (preference & TEAMTP_DEFENDER) {
defenders[numdefenders++] = teammates[i];
}
else if (preference & TEAMTP_ATTACKER) {
attackers[numattackers++] = teammates[i];
}
else {
roamers[numroamers++] = teammates[i];
}
}
numteammates = 0;
//defenders at the front of the list
memcpy(&teammates[numteammates], defenders, numdefenders * sizeof(int));
numteammates += numdefenders;
//roamers in the middle
memcpy(&teammates[numteammates], roamers, numroamers * sizeof(int));
numteammates += numroamers;
//attacker in the back of the list
memcpy(&teammates[numteammates], attackers, numattackers * sizeof(int));
numteammates += numattackers;
return numteammates;
}
/*
==================
BotSayTeamOrders
==================
*/
void BotSayTeamOrderAlways(bot_state_t *bs, int toclient) {
char teamchat[MAX_MESSAGE_SIZE];
char buf[MAX_MESSAGE_SIZE];
char name[MAX_NETNAME];
//if the bot is talking to itself
if (bs->client == toclient) {
//don't show the message just put it in the console message queue
trap_BotGetChatMessage(bs->cs, buf, sizeof(buf));
ClientName(bs->client, name, sizeof(name));
Com_sprintf(teamchat, sizeof(teamchat), EC"(%s"EC")"EC": %s", name, buf);
trap_BotQueueConsoleMessage(bs->cs, CMS_CHAT, teamchat);
}
else {
trap_BotEnterChat(bs->cs, toclient, CHAT_TELL);
}
}
/*
==================
BotSayTeamOrders
==================
*/
void BotSayTeamOrder(bot_state_t *bs, int toclient) {
#ifdef MISSIONPACK
// voice chats only
char buf[MAX_MESSAGE_SIZE];
trap_BotGetChatMessage(bs->cs, buf, sizeof(buf));
#else
BotSayTeamOrderAlways(bs, toclient);
#endif
}
/*
==================
BotVoiceChat
==================
*/
void BotVoiceChat(bot_state_t *bs, int toclient, char *voicechat) {
#ifdef MISSIONPACK
if (toclient == -1)
// voice only say team
trap_EA_Command(bs->client, va("vsay_team %s", voicechat));
else
// voice only tell single player
trap_EA_Command(bs->client, va("vtell %d %s", toclient, voicechat));
#endif
}
/*
==================
BotVoiceChatOnly
==================
*/
void BotVoiceChatOnly(bot_state_t *bs, int toclient, char *voicechat) {
#ifdef MISSIONPACK
if (toclient == -1)
// voice only say team
trap_EA_Command(bs->client, va("vosay_team %s", voicechat));
else
// voice only tell single player
trap_EA_Command(bs->client, va("votell %d %s", toclient, voicechat));
#endif
}
/*
==================
BotSayVoiceTeamOrder
==================
*/
void BotSayVoiceTeamOrder(bot_state_t *bs, int toclient, char *voicechat) {
#ifdef MISSIONPACK
BotVoiceChat(bs, toclient, voicechat);
#endif
}
/*
==================
BotCTFOrders
==================
*/
void BotCTFOrders_BothFlagsNotAtBase(bot_state_t *bs) {
int numteammates, defenders, attackers, i, other;
int teammates[MAX_CLIENTS];
char name[MAX_NETNAME], carriername[MAX_NETNAME];
numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
//different orders based on the number of team mates
switch(bs->numteammates) {
case 1: break;
case 2:
{
//tell the one not carrying the flag to attack the enemy base
if (teammates[0] != bs->flagcarrier) other = teammates[0];
else other = teammates[1];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, other);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_GETFLAG);
break;
}
case 3:
{
//tell the one closest to the base not carrying the flag to accompany the flag carrier
if (teammates[0] != bs->flagcarrier) other = teammates[0];
else other = teammates[1];
ClientName(other, name, sizeof(name));
if ( bs->flagcarrier != -1 ) {
ClientName(bs->flagcarrier, carriername, sizeof(carriername));
if (bs->flagcarrier == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_FOLLOWME);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_FOLLOWFLAGCARRIER);
}
}
else {
//
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_GETFLAG);
}
BotSayTeamOrder(bs, other);
//tell the one furthest from the the base not carrying the flag to get the enemy flag
if (teammates[2] != bs->flagcarrier) other = teammates[2];
else other = teammates[1];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, other);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_RETURNFLAG);
break;
}
default:
{
defenders = (int) (float) numteammates * 0.4 + 0.5;
if (defenders > 4) defenders = 4;
attackers = (int) (float) numteammates * 0.5 + 0.5;
if (attackers > 5) attackers = 5;
if (bs->flagcarrier != -1) {
ClientName(bs->flagcarrier, carriername, sizeof(carriername));
for (i = 0; i < defenders; i++) {
//
if (teammates[i] == bs->flagcarrier) {
continue;
}
//
ClientName(teammates[i], name, sizeof(name));
if (bs->flagcarrier == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_FOLLOWME);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_FOLLOWFLAGCARRIER);
}
BotSayTeamOrder(bs, teammates[i]);
}
}
else {
for (i = 0; i < defenders; i++) {
//
if (teammates[i] == bs->flagcarrier) {
continue;
}
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_GETFLAG);
BotSayTeamOrder(bs, teammates[i]);
}
}
for (i = 0; i < attackers; i++) {
//
if (teammates[numteammates - i - 1] == bs->flagcarrier) {
continue;
}
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_RETURNFLAG);
}
//
break;
}
}
}
/*
==================
BotCTFOrders
==================
*/
void BotCTFOrders_FlagNotAtBase(bot_state_t *bs) {
int numteammates, defenders, attackers, i;
int teammates[MAX_CLIENTS];
char name[MAX_NETNAME];
numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
//passive strategy
if (!(bs->ctfstrategy & CTFS_AGRESSIVE)) {
//different orders based on the number of team mates
switch(bs->numteammates) {
case 1: break;
case 2:
{
// keep one near the base for when the flag is returned
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
break;
}
case 3:
{
//keep one near the base for when the flag is returned
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other two get the flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
//
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
break;
}
default:
{
//keep some people near the base for when the flag is returned
defenders = (int) (float) numteammates * 0.3 + 0.5;
if (defenders > 3) defenders = 3;
attackers = (int) (float) numteammates * 0.6 + 0.5;
if (attackers > 6) attackers = 6;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_GETFLAG);
}
//
break;
}
}
}
else {
//different orders based on the number of team mates
switch(bs->numteammates) {
case 1: break;
case 2:
{
//both will go for the enemy flag
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_GETFLAG);
//
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
break;
}
case 3:
{
//everyone go for the flag
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_GETFLAG);
//
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
//
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
break;
}
default:
{
//keep some people near the base for when the flag is returned
defenders = (int) (float) numteammates * 0.2 + 0.5;
if (defenders > 2) defenders = 2;
attackers = (int) (float) numteammates * 0.7 + 0.5;
if (attackers > 7) attackers = 7;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
}
//
break;
}
}
}
}
/*
==================
BotCTFOrders
==================
*/
void BotCTFOrders_EnemyFlagNotAtBase(bot_state_t *bs) {
int numteammates, defenders, attackers, i, other;
int teammates[MAX_CLIENTS];
char name[MAX_NETNAME], carriername[MAX_NETNAME];
numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//tell the one not carrying the flag to defend the base
if (teammates[0] == bs->flagcarrier) other = teammates[1];
else other = teammates[0];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, other);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_DEFEND);
break;
}
case 3:
{
//tell the one closest to the base not carrying the flag to defend the base
if (teammates[0] != bs->flagcarrier) other = teammates[0];
else other = teammates[1];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, other);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_DEFEND);
//tell the other also to defend the base
if (teammates[2] != bs->flagcarrier) other = teammates[2];
else other = teammates[1];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, other);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_DEFEND);
break;
}
default:
{
//60% will defend the base
defenders = (int) (float) numteammates * 0.6 + 0.5;
if (defenders > 6) defenders = 6;
//30% accompanies the flag carrier
attackers = (int) (float) numteammates * 0.3 + 0.5;
if (attackers > 3) attackers = 3;
for (i = 0; i < defenders; i++) {
//
if (teammates[i] == bs->flagcarrier) {
continue;
}
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
// if we have a flag carrier
if ( bs->flagcarrier != -1 ) {
ClientName(bs->flagcarrier, carriername, sizeof(carriername));
for (i = 0; i < attackers; i++) {
//
if (teammates[numteammates - i - 1] == bs->flagcarrier) {
continue;
}
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
if (bs->flagcarrier == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_FOLLOWME);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_FOLLOWFLAGCARRIER);
}
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
}
}
else {
for (i = 0; i < attackers; i++) {
//
if (teammates[numteammates - i - 1] == bs->flagcarrier) {
continue;
}
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
}
}
//
break;
}
}
}
/*
==================
BotCTFOrders
==================
*/
void BotCTFOrders_BothFlagsAtBase(bot_state_t *bs) {
int numteammates, defenders, attackers, i;
int teammates[MAX_CLIENTS];
char name[MAX_NETNAME];
//sort team mates by travel time to base
numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
//sort team mates by CTF preference
BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
//passive strategy
if (!(bs->ctfstrategy & CTFS_AGRESSIVE)) {
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will get the flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the second one closest to the base will defend the base
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_DEFEND);
//the other will get the flag
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
break;
}
default:
{
defenders = (int) (float) numteammates * 0.5 + 0.5;
if (defenders > 5) defenders = 5;
attackers = (int) (float) numteammates * 0.4 + 0.5;
if (attackers > 4) attackers = 4;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
}
//
break;
}
}
}
else {
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will get the flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the others should go for the enemy flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
//
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
break;
}
default:
{
defenders = (int) (float) numteammates * 0.4 + 0.5;
if (defenders > 4) defenders = 4;
attackers = (int) (float) numteammates * 0.5 + 0.5;
if (attackers > 5) attackers = 5;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
}
//
break;
}
}
}
}
/*
==================
BotCTFOrders
==================
*/
void BotCTFOrders(bot_state_t *bs) {
int flagstatus;
//
if (BotTeam(bs) == TEAM_RED) flagstatus = bs->redflagstatus * 2 + bs->blueflagstatus;
else flagstatus = bs->blueflagstatus * 2 + bs->redflagstatus;
//
switch(flagstatus) {
case 0: BotCTFOrders_BothFlagsAtBase(bs); break;
case 1: BotCTFOrders_EnemyFlagNotAtBase(bs); break;
case 2: BotCTFOrders_FlagNotAtBase(bs); break;
case 3: BotCTFOrders_BothFlagsNotAtBase(bs); break;
}
}
/*
==================
BotCreateGroup
==================
*/
void BotCreateGroup(bot_state_t *bs, int *teammates, int groupsize) {
char name[MAX_NETNAME], leadername[MAX_NETNAME];
int i;
// the others in the group will follow the teammates[0]
ClientName(teammates[0], leadername, sizeof(leadername));
for (i = 1; i < groupsize; i++)
{
ClientName(teammates[i], name, sizeof(name));
if (teammates[0] == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, leadername, NULL);
}
BotSayTeamOrderAlways(bs, teammates[i]);
}
}
/*
==================
BotTeamOrders
FIXME: defend key areas?
==================
*/
void BotTeamOrders(bot_state_t *bs) {
int teammates[MAX_CLIENTS];
int numteammates, i;
char buf[MAX_INFO_STRING];
static int maxclients;
if (!maxclients)
maxclients = trap_Cvar_VariableIntegerValue("sv_maxclients");
numteammates = 0;
for (i = 0; i < maxclients && i < MAX_CLIENTS; i++) {
trap_GetConfigstring(CS_PLAYERS+i, buf, sizeof(buf));
//if no config string or no name
if (!strlen(buf) || !strlen(Info_ValueForKey(buf, "n"))) continue;
//skip spectators
if (atoi(Info_ValueForKey(buf, "t")) == TEAM_SPECTATOR) continue;
//
if (BotSameTeam(bs, i)) {
teammates[numteammates] = i;
numteammates++;
}
}
//
switch(numteammates) {
case 1: break;
case 2:
{
//nothing special
break;
}
case 3:
{
//have one follow another and one free roaming
BotCreateGroup(bs, teammates, 2);
break;
}
case 4:
{
BotCreateGroup(bs, teammates, 2); //a group of 2
BotCreateGroup(bs, &teammates[2], 2); //a group of 2
break;
}
case 5:
{
BotCreateGroup(bs, teammates, 2); //a group of 2
BotCreateGroup(bs, &teammates[2], 3); //a group of 3
break;
}
default:
{
if (numteammates <= 10) {
for (i = 0; i < numteammates / 2; i++) {
BotCreateGroup(bs, &teammates[i*2], 2); //groups of 2
}
}
break;
}
}
}
#ifdef MISSIONPACK
/*
==================
Bot1FCTFOrders_FlagAtCenter
X% defend the base, Y% get the flag
==================
*/
void Bot1FCTFOrders_FlagAtCenter(bot_state_t *bs) {
int numteammates, defenders, attackers, i;
int teammates[MAX_CLIENTS];
char name[MAX_NETNAME];
//sort team mates by travel time to base
numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
//sort team mates by CTF preference
BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
//passive strategy
if (!(bs->ctfstrategy & CTFS_AGRESSIVE)) {
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will get the flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the second one closest to the base will defend the base
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will get the flag
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
break;
}
default:
{
//50% defend the base
defenders = (int) (float) numteammates * 0.5 + 0.5;
if (defenders > 5) defenders = 5;
//40% get the flag
attackers = (int) (float) numteammates * 0.4 + 0.5;
if (attackers > 4) attackers = 4;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
}
//
break;
}
}
}
else { //agressive
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will get the flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the others should go for the enemy flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
//
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
break;
}
default:
{
//30% defend the base
defenders = (int) (float) numteammates * 0.3 + 0.5;
if (defenders > 3) defenders = 3;
//60% get the flag
attackers = (int) (float) numteammates * 0.6 + 0.5;
if (attackers > 6) attackers = 6;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
}
//
break;
}
}
}
}
/*
==================
Bot1FCTFOrders_TeamHasFlag
X% towards neutral flag, Y% go towards enemy base and accompany flag carrier if visible
==================
*/
void Bot1FCTFOrders_TeamHasFlag(bot_state_t *bs) {
int numteammates, defenders, attackers, i, other;
int teammates[MAX_CLIENTS];
char name[MAX_NETNAME], carriername[MAX_NETNAME];
//sort team mates by travel time to base
numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
//sort team mates by CTF preference
BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
//passive strategy
if (!(bs->ctfstrategy & CTFS_AGRESSIVE)) {
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//tell the one not carrying the flag to attack the enemy base
if (teammates[0] == bs->flagcarrier) other = teammates[1];
else other = teammates[0];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_attackenemybase", name, NULL);
BotSayTeamOrder(bs, other);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_OFFENSE);
break;
}
case 3:
{
//tell the one closest to the base not carrying the flag to defend the base
if (teammates[0] != bs->flagcarrier) other = teammates[0];
else other = teammates[1];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, other);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_DEFEND);
//tell the one furthest from the base not carrying the flag to accompany the flag carrier
if (teammates[2] != bs->flagcarrier) other = teammates[2];
else other = teammates[1];
ClientName(other, name, sizeof(name));
if ( bs->flagcarrier != -1 ) {
ClientName(bs->flagcarrier, carriername, sizeof(carriername));
if (bs->flagcarrier == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_FOLLOWME);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_FOLLOWFLAGCARRIER);
}
}
else {
//
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_GETFLAG);
}
BotSayTeamOrder(bs, other);
break;
}
default:
{
//30% will defend the base
defenders = (int) (float) numteammates * 0.3 + 0.5;
if (defenders > 3) defenders = 3;
//70% accompanies the flag carrier
attackers = (int) (float) numteammates * 0.7 + 0.5;
if (attackers > 7) attackers = 7;
for (i = 0; i < defenders; i++) {
//
if (teammates[i] == bs->flagcarrier) {
continue;
}
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
if (bs->flagcarrier != -1) {
ClientName(bs->flagcarrier, carriername, sizeof(carriername));
for (i = 0; i < attackers; i++) {
//
if (teammates[numteammates - i - 1] == bs->flagcarrier) {
continue;
}
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
if (bs->flagcarrier == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_FOLLOWME);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_FOLLOWFLAGCARRIER);
}
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
}
}
else {
for (i = 0; i < attackers; i++) {
//
if (teammates[numteammates - i - 1] == bs->flagcarrier) {
continue;
}
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
}
}
//
break;
}
}
}
else { //agressive
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//tell the one not carrying the flag to defend the base
if (teammates[0] == bs->flagcarrier) other = teammates[1];
else other = teammates[0];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, other);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_DEFEND);
break;
}
case 3:
{
//tell the one closest to the base not carrying the flag to defend the base
if (teammates[0] != bs->flagcarrier) other = teammates[0];
else other = teammates[1];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, other);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_DEFEND);
//tell the one furthest from the base not carrying the flag to accompany the flag carrier
if (teammates[2] != bs->flagcarrier) other = teammates[2];
else other = teammates[1];
ClientName(other, name, sizeof(name));
ClientName(bs->flagcarrier, carriername, sizeof(carriername));
if (bs->flagcarrier == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_FOLLOWME);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
BotSayVoiceTeamOrder(bs, other, VOICECHAT_FOLLOWFLAGCARRIER);
}
BotSayTeamOrder(bs, other);
break;
}
default:
{
//20% will defend the base
defenders = (int) (float) numteammates * 0.2 + 0.5;
if (defenders > 2) defenders = 2;
//80% accompanies the flag carrier
attackers = (int) (float) numteammates * 0.8 + 0.5;
if (attackers > 8) attackers = 8;
for (i = 0; i < defenders; i++) {
//
if (teammates[i] == bs->flagcarrier) {
continue;
}
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
ClientName(bs->flagcarrier, carriername, sizeof(carriername));
for (i = 0; i < attackers; i++) {
//
if (teammates[numteammates - i - 1] == bs->flagcarrier) {
continue;
}
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
if (bs->flagcarrier == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_FOLLOWME);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_FOLLOWFLAGCARRIER);
}
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
}
//
break;
}
}
}
}
/*
==================
Bot1FCTFOrders_EnemyHasFlag
X% defend the base, Y% towards neutral flag
==================
*/
void Bot1FCTFOrders_EnemyHasFlag(bot_state_t *bs) {
int numteammates, defenders, attackers, i;
int teammates[MAX_CLIENTS];
char name[MAX_NETNAME];
//sort team mates by travel time to base
numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
//sort team mates by CTF preference
BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
//passive strategy
if (!(bs->ctfstrategy & CTFS_AGRESSIVE)) {
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//both defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_DEFEND);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the second one closest to the base will defend the base
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_DEFEND);
//the other will also defend the base
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_DEFEND);
break;
}
default:
{
//80% will defend the base
defenders = (int) (float) numteammates * 0.8 + 0.5;
if (defenders > 8) defenders = 8;
//10% will try to return the flag
attackers = (int) (float) numteammates * 0.1 + 0.5;
if (attackers > 1) attackers = 1;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_returnflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
}
//
break;
}
}
}
else { //agressive
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will get the flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_DEFEND);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the others should go for the enemy flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_DEFEND);
//
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_returnflag", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
break;
}
default:
{
//70% defend the base
defenders = (int) (float) numteammates * 0.7 + 0.5;
if (defenders > 7) defenders = 7;
//20% try to return the flag
attackers = (int) (float) numteammates * 0.2 + 0.5;
if (attackers > 2) attackers = 2;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_returnflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
}
//
break;
}
}
}
}
/*
==================
Bot1FCTFOrders_EnemyDroppedFlag
X% defend the base, Y% get the flag
==================
*/
void Bot1FCTFOrders_EnemyDroppedFlag(bot_state_t *bs) {
int numteammates, defenders, attackers, i;
int teammates[MAX_CLIENTS];
char name[MAX_NETNAME];
//sort team mates by travel time to base
numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
//sort team mates by CTF preference
BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
//passive strategy
if (!(bs->ctfstrategy & CTFS_AGRESSIVE)) {
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will get the flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the second one closest to the base will defend the base
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_DEFEND);
//the other will get the flag
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
break;
}
default:
{
//50% defend the base
defenders = (int) (float) numteammates * 0.5 + 0.5;
if (defenders > 5) defenders = 5;
//40% get the flag
attackers = (int) (float) numteammates * 0.4 + 0.5;
if (attackers > 4) attackers = 4;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
}
//
break;
}
}
}
else { //agressive
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will get the flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the others should go for the enemy flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_GETFLAG);
//
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_GETFLAG);
break;
}
default:
{
//30% defend the base
defenders = (int) (float) numteammates * 0.3 + 0.5;
if (defenders > 3) defenders = 3;
//60% get the flag
attackers = (int) (float) numteammates * 0.6 + 0.5;
if (attackers > 6) attackers = 6;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_GETFLAG);
}
//
break;
}
}
}
}
/*
==================
Bot1FCTFOrders
==================
*/
void Bot1FCTFOrders(bot_state_t *bs) {
switch(bs->neutralflagstatus) {
case 0: Bot1FCTFOrders_FlagAtCenter(bs); break;
case 1: Bot1FCTFOrders_TeamHasFlag(bs); break;
case 2: Bot1FCTFOrders_EnemyHasFlag(bs); break;
case 3: Bot1FCTFOrders_EnemyDroppedFlag(bs); break;
}
}
/*
==================
BotObeliskOrders
X% in defence Y% in offence
==================
*/
void BotObeliskOrders(bot_state_t *bs) {
int numteammates, defenders, attackers, i;
int teammates[MAX_CLIENTS];
char name[MAX_NETNAME];
//sort team mates by travel time to base
numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
//sort team mates by CTF preference
BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
//passive strategy
if (!(bs->ctfstrategy & CTFS_AGRESSIVE)) {
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will attack the enemy base
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_attackenemybase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_OFFENSE);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the one second closest to the base also defends the base
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_DEFEND);
//the other one attacks the enemy base
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_attackenemybase", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_OFFENSE);
break;
}
default:
{
//50% defend the base
defenders = (int) (float) numteammates * 0.5 + 0.5;
if (defenders > 5) defenders = 5;
//40% attack the enemy base
attackers = (int) (float) numteammates * 0.4 + 0.5;
if (attackers > 4) attackers = 4;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_attackenemybase", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_OFFENSE);
}
//
break;
}
}
}
else {
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will attack the enemy base
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_attackenemybase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_OFFENSE);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the others attack the enemy base
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_attackenemybase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_OFFENSE);
//
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_attackenemybase", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_OFFENSE);
break;
}
default:
{
//30% defend the base
defenders = (int) (float) numteammates * 0.3 + 0.5;
if (defenders > 3) defenders = 3;
//70% attack the enemy base
attackers = (int) (float) numteammates * 0.7 + 0.5;
if (attackers > 7) attackers = 7;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_attackenemybase", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_OFFENSE);
}
//
break;
}
}
}
}
/*
==================
BotHarvesterOrders
X% defend the base, Y% harvest
==================
*/
void BotHarvesterOrders(bot_state_t *bs) {
int numteammates, defenders, attackers, i;
int teammates[MAX_CLIENTS];
char name[MAX_NETNAME];
//sort team mates by travel time to base
numteammates = BotSortTeamMatesByBaseTravelTime(bs, teammates, sizeof(teammates));
//sort team mates by CTF preference
BotSortTeamMatesByTaskPreference(bs, teammates, numteammates);
//passive strategy
if (!(bs->ctfstrategy & CTFS_AGRESSIVE)) {
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will harvest
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_harvest", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_OFFENSE);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the one second closest to the base also defends the base
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_DEFEND);
//the other one goes harvesting
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_harvest", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_OFFENSE);
break;
}
default:
{
//50% defend the base
defenders = (int) (float) numteammates * 0.5 + 0.5;
if (defenders > 5) defenders = 5;
//40% goes harvesting
attackers = (int) (float) numteammates * 0.4 + 0.5;
if (attackers > 4) attackers = 4;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_harvest", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_OFFENSE);
}
//
break;
}
}
}
else {
//different orders based on the number of team mates
switch(numteammates) {
case 1: break;
case 2:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the other will harvest
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_harvest", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_OFFENSE);
break;
}
case 3:
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
BotSayVoiceTeamOrder(bs, teammates[0], VOICECHAT_DEFEND);
//the others go harvesting
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_harvest", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
BotSayVoiceTeamOrder(bs, teammates[1], VOICECHAT_OFFENSE);
//
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_harvest", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
BotSayVoiceTeamOrder(bs, teammates[2], VOICECHAT_OFFENSE);
break;
}
default:
{
//30% defend the base
defenders = (int) (float) numteammates * 0.3 + 0.5;
if (defenders > 3) defenders = 3;
//70% go harvesting
attackers = (int) (float) numteammates * 0.7 + 0.5;
if (attackers > 7) attackers = 7;
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
BotSayVoiceTeamOrder(bs, teammates[i], VOICECHAT_DEFEND);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_harvest", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
BotSayVoiceTeamOrder(bs, teammates[numteammates - i - 1], VOICECHAT_OFFENSE);
}
//
break;
}
}
}
}
#endif
/*
==================
FindHumanTeamLeader
==================
*/
int FindHumanTeamLeader(bot_state_t *bs) {
int i;
for (i = 0; i < MAX_CLIENTS; i++) {
if ( g_entities[i].inuse ) {
// if this player is not a bot
if ( !(g_entities[i].r.svFlags & SVF_BOT) ) {
// if this player is ok with being the leader
if (!notleader[i]) {
// if this player is on the same team
if ( BotSameTeam(bs, i) ) {
ClientName(i, bs->teamleader, sizeof(bs->teamleader));
// if not yet ordered to do anything
if ( !BotSetLastOrderedTask(bs) ) {
// go on defense by default
BotVoiceChat_Defend(bs, i, SAY_TELL);
}
return qtrue;
}
}
}
}
}
return qfalse;
}
/*
==================
BotTeamAI
==================
*/
void BotTeamAI(bot_state_t *bs) {
int numteammates;
char netname[MAX_NETNAME];
//
if ( gametype < GT_TEAM )
return;
// make sure we've got a valid team leader
if (!BotValidTeamLeader(bs)) {
//
if (!FindHumanTeamLeader(bs)) {
//
if (!bs->askteamleader_time && !bs->becometeamleader_time) {
if (bs->entergame_time + 10 > FloatTime()) {
bs->askteamleader_time = FloatTime() + 5 + random() * 10;
}
else {
bs->becometeamleader_time = FloatTime() + 5 + random() * 10;
}
}
if (bs->askteamleader_time && bs->askteamleader_time < FloatTime()) {
// if asked for a team leader and no response
BotAI_BotInitialChat(bs, "whoisteamleader", NULL);
trap_BotEnterChat(bs->cs, 0, CHAT_TEAM);
bs->askteamleader_time = 0;
bs->becometeamleader_time = FloatTime() + 8 + random() * 10;
}
if (bs->becometeamleader_time && bs->becometeamleader_time < FloatTime()) {
BotAI_BotInitialChat(bs, "iamteamleader", NULL);
trap_BotEnterChat(bs->cs, 0, CHAT_TEAM);
BotSayVoiceTeamOrder(bs, -1, VOICECHAT_STARTLEADER);
ClientName(bs->client, netname, sizeof(netname));
strncpy(bs->teamleader, netname, sizeof(bs->teamleader));
bs->teamleader[sizeof(bs->teamleader)-1] = '\0';
bs->becometeamleader_time = 0;
}
return;
}
}
bs->askteamleader_time = 0;
bs->becometeamleader_time = 0;
//return if this bot is NOT the team leader
ClientName(bs->client, netname, sizeof(netname));
if (Q_stricmp(netname, bs->teamleader) != 0) return;
//
numteammates = BotNumTeamMates(bs);
//give orders
switch(gametype) {
case GT_TEAM:
{
if (bs->numteammates != numteammates || bs->forceorders) {
bs->teamgiveorders_time = FloatTime();
bs->numteammates = numteammates;
bs->forceorders = qfalse;
}
//if it's time to give orders
if (bs->teamgiveorders_time && bs->teamgiveorders_time < FloatTime() - 5) {
BotTeamOrders(bs);
//give orders again after 120 seconds
bs->teamgiveorders_time = FloatTime() + 120;
}
break;
}
case GT_CTF:
{
//if the number of team mates changed or the flag status changed
//or someone wants to know what to do
if (bs->numteammates != numteammates || bs->flagstatuschanged || bs->forceorders) {
bs->teamgiveorders_time = FloatTime();
bs->numteammates = numteammates;
bs->flagstatuschanged = qfalse;
bs->forceorders = qfalse;
}
//if there were no flag captures the last 3 minutes
if (bs->lastflagcapture_time < FloatTime() - 240) {
bs->lastflagcapture_time = FloatTime();
//randomly change the CTF strategy
if (random() < 0.4) {
bs->ctfstrategy ^= CTFS_AGRESSIVE;
bs->teamgiveorders_time = FloatTime();
}
}
//if it's time to give orders
if (bs->teamgiveorders_time && bs->teamgiveorders_time < FloatTime() - 3) {
BotCTFOrders(bs);
//
bs->teamgiveorders_time = 0;
}
break;
}
#ifdef MISSIONPACK
case GT_1FCTF:
{
if (bs->numteammates != numteammates || bs->flagstatuschanged || bs->forceorders) {
bs->teamgiveorders_time = FloatTime();
bs->numteammates = numteammates;
bs->flagstatuschanged = qfalse;
bs->forceorders = qfalse;
}
//if there were no flag captures the last 4 minutes
if (bs->lastflagcapture_time < FloatTime() - 240) {
bs->lastflagcapture_time = FloatTime();
//randomly change the CTF strategy
if (random() < 0.4) {
bs->ctfstrategy ^= CTFS_AGRESSIVE;
bs->teamgiveorders_time = FloatTime();
}
}
//if it's time to give orders
if (bs->teamgiveorders_time && bs->teamgiveorders_time < FloatTime() - 2) {
Bot1FCTFOrders(bs);
//
bs->teamgiveorders_time = 0;
}
break;
}
case GT_OBELISK:
{
if (bs->numteammates != numteammates || bs->forceorders) {
bs->teamgiveorders_time = FloatTime();
bs->numteammates = numteammates;
bs->forceorders = qfalse;
}
//if it's time to give orders
if (bs->teamgiveorders_time && bs->teamgiveorders_time < FloatTime() - 5) {
BotObeliskOrders(bs);
//give orders again after 30 seconds
bs->teamgiveorders_time = FloatTime() + 30;
}
break;
}
case GT_HARVESTER:
{
if (bs->numteammates != numteammates || bs->forceorders) {
bs->teamgiveorders_time = FloatTime();
bs->numteammates = numteammates;
bs->forceorders = qfalse;
}
//if it's time to give orders
if (bs->teamgiveorders_time && bs->teamgiveorders_time < FloatTime() - 5) {
BotHarvesterOrders(bs);
//give orders again after 30 seconds
bs->teamgiveorders_time = FloatTime() + 30;
}
break;
}
#endif
}
}
Reference in a new issue View git blame Copy permalink