ubergames
/
rpgxef
mirror of https://github.com/UberGames/rpgxEF.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

moved function declarations and updated code of ai_main

This commit is contained in:
Walter Julius Hennecke 2014-10-11 18:41:15 +02:00
parent bb08b42f1c
commit 881df8c239
15 changed files with 1128 additions and 819 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
code/game/ai_chat.c
View File

@ -103,7 +103,7 @@ static int32_t BotIsFirstInRankings(bot_state_t* bs) {
continue;
}
BotAI_GetClientState(i, &ps);
AI_main_BotAIGetClientState(i, &ps);
if (score < ps.persistant[PERS_SCORE]) {
return qfalse;
}
@ -142,7 +142,7 @@ static int32_t BotIsLastInRankings(bot_state_t* bs) {
continue;
}
BotAI_GetClientState(i, &ps);
AI_main_BotAIGetClientState(i, &ps);
if (score > ps.persistant[PERS_SCORE]) {
return qfalse;
}
@ -182,7 +182,7 @@ static char* BotFirstClientInRankings(void) {
continue;
}
BotAI_GetClientState(i, &ps);
AI_main_BotAIGetClientState(i, &ps);
if (ps.persistant[PERS_SCORE] > bestscore) {
bestscore = ps.persistant[PERS_SCORE];
bestclient = i;
@ -224,7 +224,7 @@ static char* BotLastClientInRankings(void) {
continue;
}
BotAI_GetClientState(i, &ps);
AI_main_BotAIGetClientState(i, &ps);
if (ps.persistant[PERS_SCORE] < worstscore) {
worstscore = ps.persistant[PERS_SCORE];
bestclient = i;
@ -388,7 +388,7 @@ static int32_t BotVisibleEnemies(bot_state_t* bs) {
continue;
}
BotEntityInfo(i, &entinfo);
AI_main_BotEntityInfo(i, &entinfo);
if (entinfo.valid == 0) {
continue;
@ -467,7 +467,7 @@ int BotValidChatPosition(bot_state_t* bs) {
start[2] += 1;
end[2] -= 10;
trap_AAS_PresenceTypeBoundingBox(PRESENCE_CROUCH, mins, maxs);
BotAI_Trace(&trace, start, mins, maxs, end, bs->client, MASK_SOLID);
AI_main_BotAITrace(&trace, start, mins, maxs, end, bs->client, MASK_SOLID);
if (trace.ent != ENTITYNUM_WORLD) {
return qfalse;
@ -511,7 +511,7 @@ int32_t BotChat_EnterGame(bot_state_t* bs) {
if (BotValidChatPosition(bs) == 0) {
return qfalse;
}
BotAI_BotInitialChat(bs, "game_enter",
AI_main_BotAIInitialChat(bs, "game_enter",
EasyClientName(bs->client, name, 32), // 0
BotRandomOpponentName(bs), // 1
"[invalid var]", // 2
@ -556,7 +556,7 @@ int32_t BotChat_ExitGame(bot_state_t* bs) {
return qfalse;
}
BotAI_BotInitialChat(bs, "game_exit",
AI_main_BotAIInitialChat(bs, "game_exit",
EasyClientName(bs->client, name, 32), // 0
BotRandomOpponentName(bs), // 1
"[invalid var]", // 2
@ -604,7 +604,7 @@ int32_t BotChat_StartLevel(bot_state_t* bs) {
if (BotNumActivePlayers() <= 1) {
return qfalse;
}
BotAI_BotInitialChat(bs, "level_start",
AI_main_BotAIInitialChat(bs, "level_start",
EasyClientName(bs->client, name, 32), // 0
NULL);
bs->lastchat_time = trap_AAS_Time();
@ -650,7 +650,7 @@ int32_t BotChat_EndLevel(bot_state_t* bs) {
}
if (BotIsFirstInRankings(bs) != 0) {
BotAI_BotInitialChat(bs, "level_end_victory",
AI_main_BotAIInitialChat(bs, "level_end_victory",
EasyClientName(bs->client, name, 32), // 0
BotRandomOpponentName(bs), // 1
"[invalid var]", // 2
@ -658,7 +658,7 @@ int32_t BotChat_EndLevel(bot_state_t* bs) {
BotMapTitle(), // 4
NULL);
} else if (BotIsLastInRankings(bs) != 0) {
BotAI_BotInitialChat(bs, "level_end_lose",
AI_main_BotAIInitialChat(bs, "level_end_lose",
EasyClientName(bs->client, name, 32), // 0
BotRandomOpponentName(bs), // 1
BotFirstClientInRankings(), // 2
@ -666,7 +666,7 @@ int32_t BotChat_EndLevel(bot_state_t* bs) {
BotMapTitle(), // 4
NULL);
} else {
BotAI_BotInitialChat(bs, "level_end",
AI_main_BotAIInitialChat(bs, "level_end",
EasyClientName(bs->client, name, 32), // 0
BotRandomOpponentName(bs), // 1
BotFirstClientInRankings(), // 2
@ -719,7 +719,7 @@ int32_t BotChat_Death(bot_state_t* bs) {
return qfalse;
}
BotAI_BotInitialChat(bs, "death_teammate", name, NULL);
AI_main_BotAIInitialChat(bs, "death_teammate", name, NULL);
bs->chatto = CHAT_TEAM;
} else {
//don't chat in teamplay
@ -728,13 +728,13 @@ int32_t BotChat_Death(bot_state_t* bs) {
}
if (bs->botdeathtype == MOD_WATER) {
BotAI_BotInitialChat(bs, "death_drown", BotRandomOpponentName(bs), NULL);
AI_main_BotAIInitialChat(bs, "death_drown", BotRandomOpponentName(bs), NULL);
} else if (bs->botdeathtype == MOD_SLIME) {
BotAI_BotInitialChat(bs, "death_slime", BotRandomOpponentName(bs), NULL);
AI_main_BotAIInitialChat(bs, "death_slime", BotRandomOpponentName(bs), NULL);
} else if (bs->botdeathtype == MOD_LAVA) {
BotAI_BotInitialChat(bs, "death_lava", BotRandomOpponentName(bs), NULL);
AI_main_BotAIInitialChat(bs, "death_lava", BotRandomOpponentName(bs), NULL);
} else if (bs->botdeathtype == MOD_FALLING) {
BotAI_BotInitialChat(bs, "death_cratered", BotRandomOpponentName(bs), NULL);
AI_main_BotAIInitialChat(bs, "death_cratered", BotRandomOpponentName(bs), NULL);
} else if (bs->botsuicide || //all other suicides by own weapon
bs->botdeathtype == MOD_CRUSH ||
bs->botdeathtype == MOD_SUICIDE ||
@ -743,17 +743,17 @@ int32_t BotChat_Death(bot_state_t* bs) {
bs->botdeathtype == MOD_TRIGGER_HURT ||
bs->botdeathtype == MOD_UNKNOWN ||
bs->botdeathtype == MOD_EXPLOSION)
BotAI_BotInitialChat(bs, "death_suicide", BotRandomOpponentName(bs), NULL);
AI_main_BotAIInitialChat(bs, "death_suicide", BotRandomOpponentName(bs), NULL);
else if (bs->botdeathtype == MOD_TELEFRAG) {
BotAI_BotInitialChat(bs, "death_telefrag", name, NULL);
AI_main_BotAIInitialChat(bs, "death_telefrag", name, NULL);
} else {
if (random() < trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_CHAT_INSULT, 0, 1)) {
BotAI_BotInitialChat(bs, "death_insult",
AI_main_BotAIInitialChat(bs, "death_insult",
name, // 0
BotWeaponNameForMeansOfDeath(bs->botdeathtype), // 1
NULL);
} else {
BotAI_BotInitialChat(bs, "death_praise",
AI_main_BotAIInitialChat(bs, "death_praise",
name, // 0
BotWeaponNameForMeansOfDeath(bs->botdeathtype), // 1
NULL);
@ -810,18 +810,18 @@ int32_t BotChat_Kill(bot_state_t* bs) {
bs->chatto = CHAT_ALL;
if (TeamPlayIsOn() != 0 && BotSameTeam(bs, bs->lastkilledplayer) != 0) {
BotAI_BotInitialChat(bs, "kill_teammate", name, NULL);
AI_main_BotAIInitialChat(bs, "kill_teammate", name, NULL);
bs->chatto = CHAT_TEAM;
} else {
//don't chat in teamplay
if (TeamPlayIsOn() != 0) {
return qfalse;
} else if (bs->enemydeathtype == MOD_TELEFRAG) {
BotAI_BotInitialChat(bs, "kill_telefrag", name, NULL);
AI_main_BotAIInitialChat(bs, "kill_telefrag", name, NULL);
} else if (random() < trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_CHAT_INSULT, 0, 1)) { //choose between insult and praise
BotAI_BotInitialChat(bs, "kill_insult", name, NULL);
AI_main_BotAIInitialChat(bs, "kill_insult", name, NULL);
} else {
BotAI_BotInitialChat(bs, "kill_praise", name, NULL);
AI_main_BotAIInitialChat(bs, "kill_praise", name, NULL);
}
}
bs->lastchat_time = trap_AAS_Time();
@ -874,7 +874,7 @@ int32_t BotChat_EnemySuicide(bot_state_t* bs) {
} else {
strcpy(name, "");
}
BotAI_BotInitialChat(bs, "enemy_suicide", name, NULL);
AI_main_BotAIInitialChat(bs, "enemy_suicide", name, NULL);
bs->lastchat_time = trap_AAS_Time();
bs->chatto = CHAT_ALL;
@ -935,7 +935,7 @@ int32_t BotChat_HitTalking(bot_state_t* bs) {
ClientName(g_entities[bs->client].client->lasthurt_client, name, sizeof(name));
weap = BotWeaponNameForMeansOfDeath(g_entities[bs->client].client->lasthurt_client);
BotAI_BotInitialChat(bs, "hit_talking", name, weap, NULL);
AI_main_BotAIInitialChat(bs, "hit_talking", name, weap, NULL);
bs->lastchat_time = trap_AAS_Time();
bs->chatto = CHAT_ALL;
@ -998,7 +998,7 @@ int32_t BotChat_HitNoDeath(bot_state_t* bs) {
return qfalse;
}
BotEntityInfo(bs->enemy, &entinfo);
AI_main_BotEntityInfo(bs->enemy, &entinfo);
if (EntityIsShooting(&entinfo)) {
return qfalse;
}
@ -1006,7 +1006,7 @@ int32_t BotChat_HitNoDeath(bot_state_t* bs) {
ClientName(lasthurt_client, name, sizeof(name));
weap = BotWeaponNameForMeansOfDeath(g_entities[bs->client].client->lasthurt_mod);
BotAI_BotInitialChat(bs, "hit_nodeath", name, weap, NULL);
AI_main_BotAIInitialChat(bs, "hit_nodeath", name, weap, NULL);
bs->lastchat_time = trap_AAS_Time();
bs->chatto = CHAT_ALL;
@ -1056,7 +1056,7 @@ int32_t BotChat_HitNoKill(bot_state_t* bs) {
return qfalse;
}
BotEntityInfo(bs->enemy, &entinfo);
AI_main_BotEntityInfo(bs->enemy, &entinfo);
if (EntityIsShooting(&entinfo)) {
return qfalse;
}
@ -1064,7 +1064,7 @@ int32_t BotChat_HitNoKill(bot_state_t* bs) {
ClientName(bs->enemy, name, sizeof(name));
weap = BotWeaponNameForMeansOfDeath(g_entities[bs->enemy].client->lasthurt_mod);
BotAI_BotInitialChat(bs, "hit_nokill", name, weap, NULL);
AI_main_BotAIInitialChat(bs, "hit_nokill", name, weap, NULL);
bs->lastchat_time = trap_AAS_Time();
bs->chatto = CHAT_ALL;
@ -1131,7 +1131,7 @@ int32_t BotChat_Random(bot_state_t* bs) {
}
if (random() < trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_CHAT_MISC, 0, 1)) {
BotAI_BotInitialChat(bs, "random_misc",
AI_main_BotAIInitialChat(bs, "random_misc",
BotRandomOpponentName(bs), // 0
name, // 1
"[invalid var]", // 2
@ -1140,7 +1140,7 @@ int32_t BotChat_Random(bot_state_t* bs) {
BotRandomWeaponName(), // 5
NULL);
} else {
BotAI_BotInitialChat(bs, "random_insult",
AI_main_BotAIInitialChat(bs, "random_insult",
BotRandomOpponentName(bs), // 0
name, // 1
"[invalid var]", // 2
@ -1176,7 +1176,7 @@ void BotChatTest(bot_state_t* bs) {
int num = trap_BotNumInitialChats(bs->cs, "game_enter");
for (; i < num; i++) {
BotAI_BotInitialChat(bs, "game_enter",
AI_main_BotAIInitialChat(bs, "game_enter",
EasyClientName(bs->client, name, 32), // 0
BotRandomOpponentName(bs), // 1
"[invalid var]", // 2
@ -1188,7 +1188,7 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "game_exit");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "game_exit",
AI_main_BotAIInitialChat(bs, "game_exit",
EasyClientName(bs->client, name, 32), // 0
BotRandomOpponentName(bs), // 1
"[invalid var]", // 2
@ -1200,7 +1200,7 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "level_start");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "level_start",
AI_main_BotAIInitialChat(bs, "level_start",
EasyClientName(bs->client, name, 32), // 0
NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
@ -1208,7 +1208,7 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "level_end_victory");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "level_end_victory",
AI_main_BotAIInitialChat(bs, "level_end_victory",
EasyClientName(bs->client, name, 32), // 0
BotRandomOpponentName(bs), // 1
BotFirstClientInRankings(), // 2
@ -1220,7 +1220,7 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "level_end_lose");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "level_end_lose",
AI_main_BotAIInitialChat(bs, "level_end_lose",
EasyClientName(bs->client, name, 32), // 0
BotRandomOpponentName(bs), // 1
BotFirstClientInRankings(), // 2
@ -1232,7 +1232,7 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "level_end");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "level_end",
AI_main_BotAIInitialChat(bs, "level_end",
EasyClientName(bs->client, name, 32), // 0
BotRandomOpponentName(bs), // 1
BotFirstClientInRankings(), // 2
@ -1246,43 +1246,43 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "death_drown");
for (i = 0; i < num; i++) {
//
BotAI_BotInitialChat(bs, "death_drown", name, NULL);
AI_main_BotAIInitialChat(bs, "death_drown", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "death_slime");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "death_slime", name, NULL);
AI_main_BotAIInitialChat(bs, "death_slime", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "death_lava");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "death_lava", name, NULL);
AI_main_BotAIInitialChat(bs, "death_lava", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "death_cratered");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "death_cratered", name, NULL);
AI_main_BotAIInitialChat(bs, "death_cratered", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "death_suicide");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "death_suicide", name, NULL);
AI_main_BotAIInitialChat(bs, "death_suicide", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "death_telefrag");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "death_telefrag", name, NULL);
AI_main_BotAIInitialChat(bs, "death_telefrag", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "death_gauntlet");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "death_gauntlet",
AI_main_BotAIInitialChat(bs, "death_gauntlet",
name, // 0
BotWeaponNameForMeansOfDeath(bs->botdeathtype), // 1
NULL);
@ -1291,7 +1291,7 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "death_rail");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "death_rail",
AI_main_BotAIInitialChat(bs, "death_rail",
name, // 0
BotWeaponNameForMeansOfDeath(bs->botdeathtype), // 1
NULL);
@ -1300,7 +1300,7 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "death_bfg");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "death_bfg",
AI_main_BotAIInitialChat(bs, "death_bfg",
name, // 0
BotWeaponNameForMeansOfDeath(bs->botdeathtype), // 1
NULL);
@ -1309,7 +1309,7 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "death_insult");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "death_insult",
AI_main_BotAIInitialChat(bs, "death_insult",
name, // 0
BotWeaponNameForMeansOfDeath(bs->botdeathtype), // 1
NULL);
@ -1318,7 +1318,7 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "death_praise");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "death_praise",
AI_main_BotAIInitialChat(bs, "death_praise",
name, // 0
BotWeaponNameForMeansOfDeath(bs->botdeathtype), // 1
NULL);
@ -1330,37 +1330,37 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "kill_gauntlet");
for (i = 0; i < num; i++) {
//
BotAI_BotInitialChat(bs, "kill_gauntlet", name, NULL);
AI_main_BotAIInitialChat(bs, "kill_gauntlet", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "kill_rail");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "kill_rail", name, NULL);
AI_main_BotAIInitialChat(bs, "kill_rail", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "kill_telefrag");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "kill_telefrag", name, NULL);
AI_main_BotAIInitialChat(bs, "kill_telefrag", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "kill_insult");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "kill_insult", name, NULL);
AI_main_BotAIInitialChat(bs, "kill_insult", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "kill_praise");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "kill_praise", name, NULL);
AI_main_BotAIInitialChat(bs, "kill_praise", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "enemy_suicide");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "enemy_suicide", name, NULL);
AI_main_BotAIInitialChat(bs, "enemy_suicide", name, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
@ -1368,19 +1368,19 @@ void BotChatTest(bot_state_t* bs) {
weap = BotWeaponNameForMeansOfDeath(g_entities[bs->client].client->lasthurt_client);
num = trap_BotNumInitialChats(bs->cs, "hit_talking");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "hit_talking", name, weap, NULL);
AI_main_BotAIInitialChat(bs, "hit_talking", name, weap, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "hit_nodeath");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "hit_nodeath", name, weap, NULL);
AI_main_BotAIInitialChat(bs, "hit_nodeath", name, weap, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
num = trap_BotNumInitialChats(bs->cs, "hit_nokill");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "hit_nokill", name, weap, NULL);
AI_main_BotAIInitialChat(bs, "hit_nokill", name, weap, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_ALL);
}
@ -1393,7 +1393,7 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "random_misc");
for (i = 0; i < num; i++) {
//
BotAI_BotInitialChat(bs, "random_misc",
AI_main_BotAIInitialChat(bs, "random_misc",
BotRandomOpponentName(bs), // 0
name, // 1
"[invalid var]", // 2
@ -1406,7 +1406,7 @@ void BotChatTest(bot_state_t* bs) {
num = trap_BotNumInitialChats(bs->cs, "random_insult");
for (i = 0; i < num; i++) {
BotAI_BotInitialChat(bs, "random_insult",
AI_main_BotAIInitialChat(bs, "random_insult",
BotRandomOpponentName(bs), // 0
name, // 1
"[invalid var]", // 2

102
code/game/ai_cmd.c
View File

@ -54,42 +54,42 @@ void BotPrintTeamGoal(bot_state_t *bs) {
t = bs->teamgoal_time - trap_AAS_Time();
switch (bs->ltgtype) {
case LTG_TEAMHELP:
BotAI_Print(PRT_MESSAGE, "%s: I'm gonna help a team mate for %1.0f secs\n", netname, t);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm gonna help a team mate for %1.0f secs\n", netname, t);
break;
case LTG_TEAMACCOMPANY:
BotAI_Print(PRT_MESSAGE, "%s: I'm gonna accompany a team mate for %1.0f secs\n", netname, t);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm gonna accompany a team mate for %1.0f secs\n", netname, t);
break;
case LTG_GETFLAG:
BotAI_Print(PRT_MESSAGE, "%s: I'm gonna get the flag for %1.0f secs\n", netname, t);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm gonna get the flag for %1.0f secs\n", netname, t);
break;
case LTG_RUSHBASE:
BotAI_Print(PRT_MESSAGE, "%s: I'm gonna rush to the base for %1.0f secs\n", netname, t);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm gonna rush to the base for %1.0f secs\n", netname, t);
break;
case LTG_RETURNFLAG:
BotAI_Print(PRT_MESSAGE, "%s: I'm gonna try to return the flag for %1.0f secs\n", netname, t);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm gonna try to return the flag for %1.0f secs\n", netname, t);
break;
case LTG_DEFENDKEYAREA:
BotAI_Print(PRT_MESSAGE, "%s: I'm gonna defend a key area for %1.0f secs\n", netname, t);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm gonna defend a key area for %1.0f secs\n", netname, t);
break;
case LTG_GETITEM:
BotAI_Print(PRT_MESSAGE, "%s: I'm gonna get an item for %1.0f secs\n", netname, t);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm gonna get an item for %1.0f secs\n", netname, t);
break;
case LTG_KILL:
BotAI_Print(PRT_MESSAGE, "%s: I'm gonna kill someone for %1.0f secs\n", netname, t);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm gonna kill someone for %1.0f secs\n", netname, t);
break;
case LTG_CAMP:
case LTG_CAMPORDER:
BotAI_Print(PRT_MESSAGE, "%s: I'm gonna camp for %1.0f secs\n", netname, t);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm gonna camp for %1.0f secs\n", netname, t);
break;
case LTG_PATROL:
BotAI_Print(PRT_MESSAGE, "%s: I'm gonna patrol for %1.0f secs\n", netname, t);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm gonna patrol for %1.0f secs\n", netname, t);
break;
default:
if (bs->ctfroam_time > trap_AAS_Time()) {
t = bs->ctfroam_time - trap_AAS_Time();
BotAI_Print(PRT_MESSAGE, "%s: I'm gonna roam for %1.0f secs\n", netname, t);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm gonna roam for %1.0f secs\n", netname, t);
} else {
BotAI_Print(PRT_MESSAGE, "%s: I've got a regular goal\n", netname);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I've got a regular goal\n", netname);
}
}
}
@ -459,7 +459,7 @@ int32_t BotGPSToPosition(char* buf, vec3_t position) {
break;
}
}
BotAI_Print(PRT_MESSAGE, "%d\n", sign * num);
AI_main_BotAIPrint(PRT_MESSAGE, "%d\n", sign * num);
position[i] = (float)sign * num;
}
return qtrue;
@ -517,9 +517,9 @@ static void BotMatch_HelpAccompany(bot_state_t* bs, bot_match_t* match) {
//if the bot doesn't know who to help (FindClientByName returned -1)
if (client < 0) {
if (other != 0) {
BotAI_BotInitialChat(bs, "whois", teammate, NULL);
AI_main_BotAIInitialChat(bs, "whois", teammate, NULL);
} else {
BotAI_BotInitialChat(bs, "whois", netname, NULL);
AI_main_BotAIInitialChat(bs, "whois", netname, NULL);
}
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
@ -531,7 +531,7 @@ static void BotMatch_HelpAccompany(bot_state_t* bs, bot_match_t* match) {
}
bs->teamgoal.entitynum = -1;
BotEntityInfo(client, &entinfo);
AI_main_BotEntityInfo(client, &entinfo);
//if info is valid (in PVS)
if (entinfo.valid != 0) {
int32_t areanum = BotPointAreaNum(entinfo.origin);
@ -558,8 +558,8 @@ static void BotMatch_HelpAccompany(bot_state_t* bs, bot_match_t* match) {
}
if (bs->teamgoal.entitynum < 0) {
if (other) BotAI_BotInitialChat(bs, "whereis", teammate, NULL);
else BotAI_BotInitialChat(bs, "whereareyou", netname, NULL);
if (other) AI_main_BotAIInitialChat(bs, "whereis", teammate, NULL);
else AI_main_BotAIInitialChat(bs, "whereareyou", netname, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
return;
}
@ -679,7 +679,7 @@ void BotMatch_Camp(bot_state_t *bs, bot_match_t *match) {
client = FindClientByName(netname);
//if there's no valid client with this name
if (client < 0) {
BotAI_BotInitialChat(bs, "whois", netname, NULL);
AI_main_BotAIInitialChat(bs, "whois", netname, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
return;
}
@ -698,7 +698,7 @@ void BotMatch_Camp(bot_state_t *bs, bot_match_t *match) {
if (client == bs->client) return;
//
bs->teamgoal.entitynum = -1;
BotEntityInfo(client, &entinfo);
AI_main_BotEntityInfo(client, &entinfo);
//if info is valid (in PVS)
if (entinfo.valid) {
areanum = BotPointAreaNum(entinfo.origin);
@ -715,7 +715,7 @@ void BotMatch_Camp(bot_state_t *bs, bot_match_t *match) {
}
//if the other is not visible
if (bs->teamgoal.entitynum < 0) {
BotAI_BotInitialChat(bs, "whereareyou", netname, NULL);
AI_main_BotAIInitialChat(bs, "whereareyou", netname, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
return;
}
@ -850,7 +850,7 @@ void BotMatch_TaskPreference(bot_state_t *bs, bot_match_t *match) {
BotSetTeamMateCTFPreference(bs, teammate, preference);
//
EasyClientName(teammate, teammatename, sizeof(teammatename));
BotAI_BotInitialChat(bs, "keepinmind", teammatename, NULL);
AI_main_BotAIInitialChat(bs, "keepinmind", teammatename, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
}
@ -893,7 +893,7 @@ void BotMatch_JoinSubteam(bot_state_t *bs, bot_match_t *match) {
strncpy(bs->subteam, teammate, 32);
bs->subteam[31] = '\0';
//
BotAI_BotInitialChat(bs, "joinedteam", teammate, NULL);
AI_main_BotAIInitialChat(bs, "joinedteam", teammate, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
}
@ -908,7 +908,7 @@ void BotMatch_LeaveSubteam(bot_state_t *bs, bot_match_t *match) {
if (!BotAddressedToBot(bs, match)) return;
//
if (strlen(bs->subteam)) {
BotAI_BotInitialChat(bs, "leftteam", bs->subteam, NULL);
AI_main_BotAIInitialChat(bs, "leftteam", bs->subteam, NULL);
} //end if
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
strcpy(bs->subteam, "");
@ -925,9 +925,9 @@ void BotMatch_WhichTeam(bot_state_t *bs, bot_match_t *match) {
if (!BotAddressedToBot(bs, match)) return;
//
if (strlen(bs->subteam)) {
BotAI_BotInitialChat(bs, "inteam", bs->subteam, NULL);
AI_main_BotAIInitialChat(bs, "inteam", bs->subteam, NULL);
} else {
BotAI_BotInitialChat(bs, "noteam", NULL);
AI_main_BotAIInitialChat(bs, "noteam", NULL);
}
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
}
@ -952,7 +952,7 @@ void BotMatch_CheckPoint(bot_state_t *bs, bot_match_t *match) {
areanum = BotPointAreaNum(position);
if (!areanum) {
if (BotAddressedToBot(bs, match)) {
BotAI_BotInitialChat(bs, "checkpoint_invalid", NULL);
AI_main_BotAIInitialChat(bs, "checkpoint_invalid", NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
}
return;
@ -979,7 +979,7 @@ void BotMatch_CheckPoint(bot_state_t *bs, bot_match_t *match) {
cp->goal.origin[1],
cp->goal.origin[2]);
BotAI_BotInitialChat(bs, "checkpoint_confirm", cp->name, buf, NULL);
AI_main_BotAIInitialChat(bs, "checkpoint_confirm", cp->name, buf, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
}
}
@ -1020,7 +1020,7 @@ void BotMatch_Dismiss(bot_state_t *bs, bot_match_t *match) {
bs->ltgtype = 0;
bs->lead_time = 0;
//
BotAI_BotInitialChat(bs, "dismissed", NULL);
AI_main_BotAIInitialChat(bs, "dismissed", NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
}
@ -1113,62 +1113,62 @@ void BotMatch_WhatAreYouDoing(bot_state_t *bs, bot_match_t *match) {
case LTG_TEAMHELP:
{
EasyClientName(bs->teammate, netname, sizeof(netname));
BotAI_BotInitialChat(bs, "helping", netname, NULL);
AI_main_BotAIInitialChat(bs, "helping", netname, NULL);
break;
}
case LTG_TEAMACCOMPANY:
{
EasyClientName(bs->teammate, netname, sizeof(netname));
BotAI_BotInitialChat(bs, "accompanying", netname, NULL);
AI_main_BotAIInitialChat(bs, "accompanying", netname, NULL);
break;
}
case LTG_DEFENDKEYAREA:
{
trap_BotGoalName(bs->teamgoal.number, goalname, sizeof(goalname));
BotAI_BotInitialChat(bs, "defending", goalname, NULL);
AI_main_BotAIInitialChat(bs, "defending", goalname, NULL);
break;
}
case LTG_GETITEM:
{
trap_BotGoalName(bs->teamgoal.number, goalname, sizeof(goalname));
BotAI_BotInitialChat(bs, "gettingitem", goalname, NULL);
AI_main_BotAIInitialChat(bs, "gettingitem", goalname, NULL);
break;
}
case LTG_KILL:
{
ClientName(bs->teamgoal.entitynum, netname, sizeof(netname));
BotAI_BotInitialChat(bs, "killing", netname, NULL);
AI_main_BotAIInitialChat(bs, "killing", netname, NULL);
break;
}
case LTG_CAMP:
case LTG_CAMPORDER:
{
BotAI_BotInitialChat(bs, "camping", NULL);
AI_main_BotAIInitialChat(bs, "camping", NULL);
break;
}
case LTG_PATROL:
{
BotAI_BotInitialChat(bs, "patrolling", NULL);
AI_main_BotAIInitialChat(bs, "patrolling", NULL);
break;
}
case LTG_GETFLAG:
{
BotAI_BotInitialChat(bs, "capturingflag", NULL);
AI_main_BotAIInitialChat(bs, "capturingflag", NULL);
break;
}
case LTG_RUSHBASE:
{
BotAI_BotInitialChat(bs, "rushingbase", NULL);
AI_main_BotAIInitialChat(bs, "rushingbase", NULL);
break;
}
case LTG_RETURNFLAG:
{
BotAI_BotInitialChat(bs, "returningflag", NULL);
AI_main_BotAIInitialChat(bs, "returningflag", NULL);
break;
}
default:
{
BotAI_BotInitialChat(bs, "roaming", NULL);
AI_main_BotAIInitialChat(bs, "roaming", NULL);
break;
}
}
@ -1212,7 +1212,7 @@ float BotNearestVisibleItem(bot_state_t *bs, char *itemname, bot_goal_t *goal) {
dist = VectorLength(dir);
if (dist < bestdist) {
//trace from start to end
BotAI_Trace(&trace, bs->eye, NULL, NULL, tmpgoal.origin, bs->client, CONTENTS_SOLID | CONTENTS_PLAYERCLIP);
AI_main_BotAITrace(&trace, bs->eye, NULL, NULL, tmpgoal.origin, bs->client, CONTENTS_SOLID | CONTENTS_PLAYERCLIP);
if (trace.fraction >= 1.0) {
bestdist = dist;
memcpy(goal, &tmpgoal, sizeof(bot_goal_t));
@ -1271,14 +1271,14 @@ void BotMatch_WhereAreYou(bot_state_t *bs, bot_match_t *match) {
redflagtt = trap_AAS_AreaTravelTimeToGoalArea(bs->areanum, bs->origin, ctf_redflag.areanum, TFL_DEFAULT);
blueflagtt = trap_AAS_AreaTravelTimeToGoalArea(bs->areanum, bs->origin, ctf_blueflag.areanum, TFL_DEFAULT);
if (redflagtt < (redflagtt + blueflagtt) * 0.4) {
BotAI_BotInitialChat(bs, "ctflocation", nearbyitems[bestitem], "red", NULL);
AI_main_BotAIInitialChat(bs, "ctflocation", nearbyitems[bestitem], "red", NULL);
} else if (blueflagtt < (redflagtt + blueflagtt) * 0.4) {
BotAI_BotInitialChat(bs, "ctflocation", nearbyitems[bestitem], "blue", NULL);
AI_main_BotAIInitialChat(bs, "ctflocation", nearbyitems[bestitem], "blue", NULL);
} else {
BotAI_BotInitialChat(bs, "location", nearbyitems[bestitem], NULL);
AI_main_BotAIInitialChat(bs, "location", nearbyitems[bestitem], NULL);
}
} else {
BotAI_BotInitialChat(bs, "location", nearbyitems[bestitem], NULL);
AI_main_BotAIInitialChat(bs, "location", nearbyitems[bestitem], NULL);
}
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
}
@ -1319,13 +1319,13 @@ void BotMatch_LeadTheWay(bot_state_t *bs, bot_match_t *match) {
}
//if the bot doesn't know who to help (FindClientByName returned -1)
if (client < 0) {
BotAI_BotInitialChat(bs, "whois", netname, NULL);
AI_main_BotAIInitialChat(bs, "whois", netname, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
return;
}
//
bs->lead_teamgoal.entitynum = -1;
BotEntityInfo(client, &entinfo);
AI_main_BotEntityInfo(client, &entinfo);
//if info is valid (in PVS)
if (entinfo.valid) {
int32_t areanum = BotPointAreaNum(entinfo.origin);
@ -1339,8 +1339,8 @@ void BotMatch_LeadTheWay(bot_state_t *bs, bot_match_t *match) {
}
if (bs->teamgoal.entitynum < 0) {
if (other) BotAI_BotInitialChat(bs, "whereis", teammate, NULL);
else BotAI_BotInitialChat(bs, "whereareyou", netname, NULL);
if (other) AI_main_BotAIInitialChat(bs, "whereis", teammate, NULL);
else AI_main_BotAIInitialChat(bs, "whereareyou", netname, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
return;
}
@ -1367,7 +1367,7 @@ void BotMatch_Kill(bot_state_t *bs, bot_match_t *match) {
//
client = FindEnemyByName(bs, enemy);
if (client < 0) {
BotAI_BotInitialChat(bs, "whois", enemy, NULL);
AI_main_BotAIInitialChat(bs, "whois", enemy, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
return;
}
@ -1589,7 +1589,7 @@ int32_t BotMatchMessage(bot_state_t *bs, char *message) {
}
default:
{
BotAI_Print(PRT_MESSAGE, "unknown match type\n");
AI_main_BotAIPrint(PRT_MESSAGE, "unknown match type\n");
break;
}
}

21
code/game/ai_common.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef _AI_COMMON_H
#define _AI_COMMON_H
//some maxs
#define MAX_NETNAME 36
#define MAX_FILEPATH 144
//bot settings
/** \struct bot_settings_t
* Containing settings for bots.
*/
typedef struct bot_settings_s {
char characterfile[MAX_FILEPATH]; /*!< filename of character file */
int skill; /*!< skill level */
char team[MAX_FILEPATH]; /*!< team */
char pclass[MAX_FILEPATH]; /*!< class */
} bot_settings_t;
#define AI_Assert(ptr, ret) if(ptr == NULL) { return ret; }
#endif /* _AI_COMMON_H */

78
code/game/ai_dmnet.c
View File

@ -65,11 +65,11 @@ void BotDumpNodeSwitches(bot_state_t *bs) {
char netname[MAX_NETNAME];
ClientName(bs->client, netname, sizeof(netname));
BotAI_Print(PRT_MESSAGE, "%s at %1.1f switched more than %d AI nodes\n", netname, trap_AAS_Time(), MAX_NODESWITCHES);
AI_main_BotAIPrint(PRT_MESSAGE, "%s at %1.1f switched more than %d AI nodes\n", netname, trap_AAS_Time(), MAX_NODESWITCHES);
for (i = 0; i < numnodeswitches; i++) {
BotAI_Print(PRT_MESSAGE, "%s", nodeswitch[i]);
AI_main_BotAIPrint(PRT_MESSAGE, "%s", nodeswitch[i]);
}
BotAI_Print(PRT_FATAL, "");
AI_main_BotAIPrint(PRT_FATAL, "");
}
/*
@ -84,7 +84,7 @@ void BotRecordNodeSwitch(bot_state_t *bs, char *node, char *str) {
Com_sprintf(nodeswitch[numnodeswitches], 144, "%s at %2.1f entered %s: %s\n", netname, trap_AAS_Time(), node, str);
#ifdef DEBUG
if (0) {
BotAI_Print(PRT_MESSAGE, nodeswitch[numnodeswitches]);
AI_main_BotAIPrint(PRT_MESSAGE, nodeswitch[numnodeswitches]);
}
#endif //DEBUG
numnodeswitches++;
@ -102,10 +102,10 @@ int BotGetAirGoal(bot_state_t *bs, bot_goal_t *goal) {
//trace up until we hit solid
VectorCopy(bs->origin, end);
end[2] += 1000;
BotAI_Trace(&bsptrace, bs->origin, mins, maxs, end, bs->entitynum, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
AI_main_BotAITrace(&bsptrace, bs->origin, mins, maxs, end, bs->entitynum, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
//trace down until we hit water
VectorCopy(bsptrace.endpos, end);
BotAI_Trace(&bsptrace, end, mins, maxs, bs->origin, bs->entitynum, CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA);
AI_main_BotAITrace(&bsptrace, end, mins, maxs, bs->origin, bs->entitynum, CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA);
//if we found the water surface
if (bsptrace.fraction > 0) {
int areanum = BotPointAreaNum(bsptrace.endpos);
@ -319,7 +319,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
if (bs->ltgtype == LTG_TEAMHELP && !retreat) {
//check for bot typing status message
if (bs->teammessage_time && bs->teammessage_time < trap_AAS_Time()) {
BotAI_BotInitialChat(bs, "help_start", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
AI_main_BotAIInitialChat(bs, "help_start", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->teammessage_time = 0;
}
@ -329,7 +329,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//if the team mate IS visible for quite some time
if (bs->teammatevisible_time < trap_AAS_Time() - 10) bs->ltgtype = 0;
//get entity information of the companion
BotEntityInfo(bs->teammate, &entinfo);
AI_main_BotEntityInfo(bs->teammate, &entinfo);
//if the team mate is visible
if (BotEntityVisible(bs->entitynum, bs->eye, bs->viewangles, 360, bs->teammate)) {
//if close just stand still there
@ -362,18 +362,18 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
if (bs->ltgtype == LTG_TEAMACCOMPANY && !retreat) {
//check for bot typing status message
if (bs->teammessage_time && bs->teammessage_time < trap_AAS_Time()) {
BotAI_BotInitialChat(bs, "accompany_start", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
AI_main_BotAIInitialChat(bs, "accompany_start", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->teammessage_time = 0;
}
//if accompanying the companion for 3 minutes
if (bs->teamgoal_time < trap_AAS_Time()) {
BotAI_BotInitialChat(bs, "accompany_stop", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
AI_main_BotAIInitialChat(bs, "accompany_stop", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->ltgtype = 0;
}
//get entity information of the companion
BotEntityInfo(bs->teammate, &entinfo);
AI_main_BotEntityInfo(bs->teammate, &entinfo);
//if the companion is visible
if (BotEntityVisible(bs->entitynum, bs->eye, bs->viewangles, 360, bs->teammate)) {
//update visible time
@ -395,7 +395,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//if not arrived yet
if (!bs->arrive_time) {
trap_EA_Gesture(bs->client);
BotAI_BotInitialChat(bs, "accompany_arrive", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
AI_main_BotAIInitialChat(bs, "accompany_arrive", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->arrive_time = trap_AAS_Time();
}
@ -455,7 +455,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
memcpy(goal, &bs->teamgoal, sizeof(bot_goal_t));
//if the companion is NOT visible for too long
if (bs->teammatevisible_time < trap_AAS_Time() - 60) {
BotAI_BotInitialChat(bs, "accompany_cannotfind", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
AI_main_BotAIInitialChat(bs, "accompany_cannotfind", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->ltgtype = 0;
}
@ -474,7 +474,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//check for bot typing status message
if (bs->teammessage_time && bs->teammessage_time < trap_AAS_Time()) {
trap_BotGoalName(bs->teamgoal.number, buf, sizeof(buf));
BotAI_BotInitialChat(bs, "defend_start", buf, NULL);
AI_main_BotAIInitialChat(bs, "defend_start", buf, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->teammessage_time = 0;
}
@ -483,7 +483,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//stop after 2 minutes
if (bs->teamgoal_time < trap_AAS_Time()) {
trap_BotGoalName(bs->teamgoal.number, buf, sizeof(buf));
BotAI_BotInitialChat(bs, "defend_stop", buf, NULL);
AI_main_BotAIInitialChat(bs, "defend_stop", buf, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->ltgtype = 0;
}
@ -501,14 +501,14 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//check for bot typing status message
if (bs->teammessage_time && bs->teammessage_time < trap_AAS_Time()) {
EasyClientName(bs->teamgoal.entitynum, buf, sizeof(buf));
BotAI_BotInitialChat(bs, "kill_start", buf, NULL);
AI_main_BotAIInitialChat(bs, "kill_start", buf, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->teammessage_time = 0;
}
//
if (bs->lastkilledplayer == bs->teamgoal.entitynum) {
EasyClientName(bs->teamgoal.entitynum, buf, sizeof(buf));
BotAI_BotInitialChat(bs, "kill_done", buf, NULL);
AI_main_BotAIInitialChat(bs, "kill_done", buf, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->lastkilledplayer = -1;
bs->ltgtype = 0;
@ -525,7 +525,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//check for bot typing status message
if (bs->teammessage_time && bs->teammessage_time < trap_AAS_Time()) {
trap_BotGoalName(bs->teamgoal.number, buf, sizeof(buf));
BotAI_BotInitialChat(bs, "getitem_start", buf, NULL);
AI_main_BotAIInitialChat(bs, "getitem_start", buf, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->teammessage_time = 0;
}
@ -538,13 +538,13 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//
if (trap_BotItemGoalInVisButNotVisible(bs->entitynum, bs->eye, bs->viewangles, goal)) {
trap_BotGoalName(bs->teamgoal.number, buf, sizeof(buf));
BotAI_BotInitialChat(bs, "getitem_notthere", buf, NULL);
AI_main_BotAIInitialChat(bs, "getitem_notthere", buf, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->ltgtype = 0;
}
else if (BotReachedGoal(bs, goal)) {
trap_BotGoalName(bs->teamgoal.number, buf, sizeof(buf));
BotAI_BotInitialChat(bs, "getitem_gotit", buf, NULL);
AI_main_BotAIInitialChat(bs, "getitem_gotit", buf, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->ltgtype = 0;
}
@ -555,7 +555,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//check for bot typing status message
if (bs->teammessage_time && bs->teammessage_time < trap_AAS_Time()) {
if (bs->ltgtype == LTG_CAMPORDER) {
BotAI_BotInitialChat(bs, "camp_start", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
AI_main_BotAIInitialChat(bs, "camp_start", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
}
bs->teammessage_time = 0;
@ -565,7 +565,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//
if (bs->teamgoal_time < trap_AAS_Time()) {
if (bs->ltgtype == LTG_CAMPORDER) {
BotAI_BotInitialChat(bs, "camp_stop", NULL);
AI_main_BotAIInitialChat(bs, "camp_stop", NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
}
bs->ltgtype = 0;
@ -577,7 +577,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//if not arrived yet
if (!bs->arrive_time) {
if (bs->ltgtype == LTG_CAMPORDER) {
BotAI_BotInitialChat(bs, "camp_arrive", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
AI_main_BotAIInitialChat(bs, "camp_arrive", EasyClientName(bs->teammate, netname, sizeof(netname)), NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
}
bs->arrive_time = trap_AAS_Time();
@ -606,7 +606,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//make sure the bot is not gonna drown
if (trap_PointContents(bs->eye,bs->entitynum) & (CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA)) {
if (bs->ltgtype == LTG_CAMPORDER) {
BotAI_BotInitialChat(bs, "camp_stop", NULL);
AI_main_BotAIInitialChat(bs, "camp_stop", NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
}
bs->ltgtype = 0;
@ -630,7 +630,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
strcat(buf, wp->name);
if (wp->next) strcat(buf, " to ");
}
BotAI_BotInitialChat(bs, "patrol_start", buf, NULL);
AI_main_BotAIInitialChat(bs, "patrol_start", buf, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->teammessage_time = 0;
}
@ -662,7 +662,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
}
//stop after 5 minutes
if (bs->teamgoal_time < trap_AAS_Time()) {
BotAI_BotInitialChat(bs, "patrol_stop", NULL);
AI_main_BotAIInitialChat(bs, "patrol_stop", NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->ltgtype = 0;
}
@ -678,7 +678,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
if (bs->ltgtype == LTG_GETFLAG) {
//check for bot typing status message
if (bs->teammessage_time && bs->teammessage_time < trap_AAS_Time()) {
BotAI_BotInitialChat(bs, "captureflag_start", NULL);
AI_main_BotAIInitialChat(bs, "captureflag_start", NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->teammessage_time = 0;
}
@ -693,7 +693,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//stop after 3 minutes
if (bs->teamgoal_time < trap_AAS_Time()) {
#ifdef DEBUG
BotAI_Print(PRT_MESSAGE, "%s: I quit getting the flag\n", ClientName(bs->client, netname, sizeof(netname)));
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I quit getting the flag\n", ClientName(bs->client, netname, sizeof(netname)));
#endif //DEBUG
bs->ltgtype = 0;
}
@ -731,7 +731,7 @@ int BotGetLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal)
//check for bot typing status message
if (bs->teammessage_time && bs->teammessage_time < trap_AAS_Time()) {
EasyClientName(bs->teamgoal.entitynum, buf, sizeof(buf));
BotAI_BotInitialChat(bs, "returnflag_start", buf, NULL);
AI_main_BotAIInitialChat(bs, "returnflag_start", buf, NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->teammessage_time = 0;
}
@ -775,12 +775,12 @@ int BotLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal) {
}
//
if (bs->leadmessage_time < 0 && -bs->leadmessage_time < trap_AAS_Time()) {
BotAI_BotInitialChat(bs, "followme", EasyClientName(bs->lead_teammate, teammate, sizeof(teammate)), NULL);
AI_main_BotAIInitialChat(bs, "followme", EasyClientName(bs->lead_teammate, teammate, sizeof(teammate)), NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->leadmessage_time = trap_AAS_Time();
}
//get entity information of the companion
BotEntityInfo(bs->lead_teammate, &entinfo);
AI_main_BotEntityInfo(bs->lead_teammate, &entinfo);
//
if (entinfo.valid) {
int areanum = BotPointAreaNum(entinfo.origin);
@ -807,7 +807,7 @@ int BotLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal) {
//if backing up towards the team mate
if (bs->leadbackup_time > trap_AAS_Time()) {
if (bs->leadmessage_time < trap_AAS_Time() - 20) {
BotAI_BotInitialChat(bs, "followme", EasyClientName(bs->lead_teammate, teammate, sizeof(teammate)), NULL);
AI_main_BotAIInitialChat(bs, "followme", EasyClientName(bs->lead_teammate, teammate, sizeof(teammate)), NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->leadmessage_time = trap_AAS_Time();
}
@ -823,7 +823,7 @@ int BotLongTermGoal(bot_state_t *bs, int tfl, int retreat, bot_goal_t *goal) {
//if quite distant from the team mate
if (dist > 500) {
if (bs->leadmessage_time < trap_AAS_Time() - 20) {
BotAI_BotInitialChat(bs, "followme", EasyClientName(bs->lead_teammate, teammate, sizeof(teammate)), NULL);
AI_main_BotAIInitialChat(bs, "followme", EasyClientName(bs->lead_teammate, teammate, sizeof(teammate)), NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->leadmessage_time = trap_AAS_Time();
}
@ -847,7 +847,7 @@ AIEnter_Intermission
void AIEnter_Intermission(bot_state_t *bs) {
BotRecordNodeSwitch(bs, "intermission", "");
//reset the bot state
BotResetState(bs);
AI_main_BotResetState(bs);
//check for end level chat
if (BotChat_EndLevel(bs)) {
trap_BotEnterChat(bs->cs, bs->client, bs->chatto);
@ -882,7 +882,7 @@ AIEnter_Observer
void AIEnter_Observer(bot_state_t *bs) {
BotRecordNodeSwitch(bs, "observer", "");
//reset the bot state
BotResetState(bs);
AI_main_BotResetState(bs);
bs->ainode = AINode_Observer;
}
@ -1050,7 +1050,7 @@ int AINode_Seek_ActivateEntity(bot_state_t *bs) {
else if (trap_BotTouchingGoal(bs->origin, goal)) {
BotChooseWeapon(bs);
#ifdef DEBUG
BotAI_Print(PRT_MESSAGE, "touched button or trigger\n");
AI_main_BotAIPrint(PRT_MESSAGE, "touched button or trigger\n");
#endif //DEBUG
bs->activate_time = 0;
}
@ -1475,7 +1475,7 @@ int AINode_Battle_Fight(bot_state_t *bs) {
return qfalse;
}
//
BotEntityInfo(bs->enemy, &entinfo);
AI_main_BotEntityInfo(bs->enemy, &entinfo);
//if the enemy is dead
if (bs->enemydeath_time) {
if (bs->enemydeath_time < trap_AAS_Time() - 1.0) {
@ -1762,7 +1762,7 @@ int AINode_Battle_Retreat(bot_state_t *bs) {
return qfalse;
}
//
BotEntityInfo(bs->enemy, &entinfo);
AI_main_BotEntityInfo(bs->enemy, &entinfo);
if (EntityIsDead(&entinfo)) {
AIEnter_Seek_LTG(bs);
return qfalse;
@ -1923,7 +1923,7 @@ int AINode_Battle_NBG(bot_state_t *bs) {
return qfalse;
}
//
BotEntityInfo(bs->enemy, &entinfo);
AI_main_BotEntityInfo(bs->enemy, &entinfo);
if (EntityIsDead(&entinfo)) {
AIEnter_Seek_NBG(bs);
return qfalse;

108
code/game/ai_dmq3.c
View File

@ -127,7 +127,7 @@ qboolean EntityIsDead(aas_entityinfo_t *entinfo) {
if (entinfo->number >= 0 && entinfo->number < MAX_CLIENTS) {
//retrieve the current client state
BotAI_GetClientState( entinfo->number, &ps );
AI_main_BotAIGetClientState( entinfo->number, &ps );
if (ps.pm_type != PM_NORMAL) return qtrue;
}
return qfalse;
@ -271,7 +271,7 @@ void BotCTFSeekGoals(bot_state_t *bs) {
//if not already going for the enemy flag
if (bs->ltgtype != LTG_GETFLAG) {
//if there's no bot team leader
if (!BotTeamLeader(bs)) {
if (!AI_main_BotTeamLeader(bs)) {
//go for the enemy flag
bs->ltgtype = LTG_GETFLAG;
//no team message
@ -372,7 +372,7 @@ char *ClientName(int client, char *name, int size) {
char buf[MAX_INFO_STRING];
if (client < 0 || client >= MAX_CLIENTS) {
BotAI_Print(PRT_ERROR, "ClientName: client out of range\n");
AI_main_BotAIPrint(PRT_ERROR, "ClientName: client out of range\n");
return "[client out of range]";
}
trap_GetConfigstring(CS_PLAYERS+client, buf, sizeof(buf));
@ -391,7 +391,7 @@ char *ClientSkin(int client, char *skin, int size) {
char buf[MAX_INFO_STRING];
if (client < 0 || client >= MAX_CLIENTS) {
BotAI_Print(PRT_ERROR, "ClientSkin: client out of range\n");
AI_main_BotAIPrint(PRT_ERROR, "ClientSkin: client out of range\n");
return "[client out of range]";
}
trap_GetConfigstring(CS_PLAYERS+client, buf, sizeof(buf));
@ -623,7 +623,7 @@ void BotUpdateBattleInventory(bot_state_t *bs, int enemy) {
vec3_t dir;
aas_entityinfo_t entinfo;
BotEntityInfo(enemy, &entinfo);
AI_main_BotEntityInfo(enemy, &entinfo);
VectorSubtract(entinfo.origin, bs->origin, dir);
bs->inventory[ENEMY_HEIGHT] = (int) dir[2];
dir[2] = 0;
@ -663,7 +663,7 @@ qboolean BotShouldDetonateDetPack(bot_state_t *bs)
// determine who would be killed in the blast radius
for (botNum = 0; botNum < MAX_CLIENTS; botNum++)
{
BotEntityInfo(botNum, &botinfo);
AI_main_BotEntityInfo(botNum, &botinfo);
if (!botinfo.valid) continue;
//calculate the distance towards the enemy
@ -838,7 +838,7 @@ bot_waypoint_t *BotCreateWayPoint(char *name, vec3_t origin, int areanum) {
wp = botai_freewaypoints;
if ( !wp ) {
BotAI_Print( PRT_WARNING, "BotCreateWayPoint: Out of waypoints\n" );
AI_main_BotAIPrint( PRT_WARNING, "BotCreateWayPoint: Out of waypoints\n" );
return NULL;
}
botai_freewaypoints = botai_freewaypoints->next;
@ -970,7 +970,7 @@ int BotWantsToRetreat(bot_state_t *bs) {
//
if (bs->enemy >= 0) {
//if the enemy is carrying a flag
BotEntityInfo(bs->enemy, &entinfo);
AI_main_BotEntityInfo(bs->enemy, &entinfo);
if (EntityCarriesFlag(&entinfo)) return qfalse;
}
//if the bot is getting the flag
@ -991,7 +991,7 @@ int BotWantsToChase(bot_state_t *bs) {
//always retreat when carrying a CTF flag
if (BotCTFCarryingFlag(bs)) return qfalse;
//if the enemy is carrying a flag
BotEntityInfo(bs->enemy, &entinfo);
AI_main_BotEntityInfo(bs->enemy, &entinfo);
if (EntityCarriesFlag(&entinfo)) return qtrue;
//if the bot is getting the flag
if (bs->ltgtype == LTG_GETFLAG) return qfalse;
@ -1150,7 +1150,7 @@ void BotRoamGoal(bot_state_t *bs, vec3_t goal) {
//add a random value to the z-coordinate (NOTE: 48 = maxjump?)
bestorg[2] += 2 * 48 * crandom();
//trace a line from the origin to the roam target
BotAI_Trace(&trace, bs->origin, NULL, NULL, bestorg, bs->entitynum, MASK_SOLID);
AI_main_BotAITrace(&trace, bs->origin, NULL, NULL, bestorg, bs->entitynum, MASK_SOLID);
//direction and length towards the roam target
VectorSubtract(trace.endpos, bs->origin, dir);
len = VectorNormalize(dir);
@ -1163,7 +1163,7 @@ void BotRoamGoal(bot_state_t *bs, vec3_t goal) {
belowbestorg[0] = bestorg[0];
belowbestorg[1] = bestorg[1];
belowbestorg[2] = bestorg[2] - 800;
BotAI_Trace(&trace, bestorg, NULL, NULL, belowbestorg, bs->entitynum, MASK_SOLID);
AI_main_BotAITrace(&trace, bestorg, NULL, NULL, belowbestorg, bs->entitynum, MASK_SOLID);
//
if (!trace.startsolid) {
trace.endpos[2]++;
@ -1214,7 +1214,7 @@ bot_moveresult_t BotAttackMove(bot_state_t *bs, int tfl) {
//initialize the movement state
BotSetupForMovement(bs);
//get the enemy entity info
BotEntityInfo(bs->enemy, &entinfo);
AI_main_BotEntityInfo(bs->enemy, &entinfo);
//direction towards the enemy
VectorSubtract(entinfo.origin, bs->origin, forward);
//the distance towards the enemy
@ -1370,7 +1370,7 @@ float BotEntityVisible(int viewer, vec3_t eye, vec3_t viewangles, float fov, int
vec3_t dir, entangles, start, end, middle;
//calculate middle of bounding box
BotEntityInfo(ent, &entinfo);
AI_main_BotEntityInfo(ent, &entinfo);
VectorAdd(entinfo.mins, entinfo.maxs, middle);
VectorScale(middle, 0.5, middle);
VectorAdd(entinfo.origin, middle, middle);
@ -1408,7 +1408,7 @@ float BotEntityVisible(int viewer, vec3_t eye, vec3_t viewangles, float fov, int
contents_mask ^= (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER);
}
//trace from start to end
BotAI_Trace(&trace, start, NULL, NULL, end, passent, contents_mask);
AI_main_BotAITrace(&trace, start, NULL, NULL, end, passent, contents_mask);
//if water was hit
waterfactor = 1.0;
if (trace.contents & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER)) {
@ -1416,7 +1416,7 @@ float BotEntityVisible(int viewer, vec3_t eye, vec3_t viewangles, float fov, int
if (1) {
//trace through the water
contents_mask &= ~(CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER);
BotAI_Trace(&trace, trace.endpos, NULL, NULL, end, passent, contents_mask);
AI_main_BotAITrace(&trace, trace.endpos, NULL, NULL, end, passent, contents_mask);
waterfactor = 0.5;
}
}
@ -1431,13 +1431,13 @@ float BotEntityVisible(int viewer, vec3_t eye, vec3_t viewangles, float fov, int
}
else if (infog) {
VectorCopy(trace.endpos, start);
BotAI_Trace(&trace, start, NULL, NULL, eye, viewer, CONTENTS_FOG);
AI_main_BotAITrace(&trace, start, NULL, NULL, eye, viewer, CONTENTS_FOG);
VectorSubtract(eye, trace.endpos, dir);
fogdist = VectorLength(dir);
}
else if (otherinfog) {
VectorCopy(trace.endpos, end);
BotAI_Trace(&trace, eye, NULL, NULL, end, viewer, CONTENTS_FOG);
AI_main_BotAITrace(&trace, eye, NULL, NULL, end, viewer, CONTENTS_FOG);
VectorSubtract(end, trace.endpos, dir);
fogdist = VectorLength(dir);
}
@ -1480,7 +1480,7 @@ int BotFindEnemy(bot_state_t *bs, int curenemy) {
bs->lasthealth = bs->inventory[INVENTORY_HEALTH];
//
if (curenemy >= 0) {
BotEntityInfo(curenemy, &curenemyinfo);
AI_main_BotEntityInfo(curenemy, &curenemyinfo);
if (EntityCarriesFlag(&curenemyinfo)) return qfalse;
VectorSubtract(curenemyinfo.origin, bs->origin, dir);
curdist = VectorLength(dir);
@ -1498,7 +1498,7 @@ int BotFindEnemy(bot_state_t *bs, int curenemy) {
//if it's the current enemy
if (i == curenemy) continue;
//
BotEntityInfo(i, &entinfo);
AI_main_BotEntityInfo(i, &entinfo);
//
if (!entinfo.valid) continue;
//if on the same team
@ -1582,7 +1582,7 @@ int BotTeamFlagCarrierVisible(bot_state_t *bs) {
for (i = 0; i < maxclients && i < MAX_CLIENTS; i++) {
if (i == bs->client) continue;
//
BotEntityInfo(i, &entinfo);
AI_main_BotEntityInfo(i, &entinfo);
//if this player is active
if (!entinfo.valid) continue;
//if this player is carrying a flag
@ -1678,7 +1678,7 @@ void BotAimAtEnemy(bot_state_t *bs) {
//
if (aim_accuracy <= 0) aim_accuracy = 0.0001;
//get the enemy entity information
BotEntityInfo(bs->enemy, &entinfo);
AI_main_BotEntityInfo(bs->enemy, &entinfo);
//if the enemy is invisible then shoot crappy most of the time
if (EntityIsInvisible(&entinfo)) {
if (random() > 0.1) aim_accuracy *= 0.4;
@ -1718,7 +1718,7 @@ void BotAimAtEnemy(bot_state_t *bs) {
start[2] += bs->cur_ps.viewheight;
start[2] += wi.offset[2];
//
BotAI_Trace(&trace, start, mins, maxs, bestorigin, bs->entitynum, MASK_SHOT);
AI_main_BotAITrace(&trace, start, mins, maxs, bestorigin, bs->entitynum, MASK_SHOT);
//if the enemy is NOT hit
if (trace.fraction <= 1 && trace.ent != entinfo.number) {
bestorigin[2] += 16;
@ -1781,13 +1781,13 @@ void BotAimAtEnemy(bot_state_t *bs) {
//try to aim at the ground in front of the enemy
VectorCopy(entinfo.origin, end);
end[2] -= 64;
BotAI_Trace(&trace, entinfo.origin, NULL, NULL, end, entinfo.number, MASK_SHOT);
AI_main_BotAITrace(&trace, entinfo.origin, NULL, NULL, end, entinfo.number, MASK_SHOT);
//
VectorCopy(bestorigin, groundtarget);
if (trace.startsolid) groundtarget[2] = entinfo.origin[2] - 16;
else groundtarget[2] = trace.endpos[2] - 8;
//trace a line from projectile start to ground target
BotAI_Trace(&trace, start, NULL, NULL, groundtarget, bs->entitynum, MASK_SHOT);
AI_main_BotAITrace(&trace, start, NULL, NULL, groundtarget, bs->entitynum, MASK_SHOT);
//if hitpoint is not vertically too far from the ground target
if (fabs(trace.endpos[2] - groundtarget[2]) < 50) {
VectorSubtract(trace.endpos, groundtarget, dir);
@ -1798,7 +1798,7 @@ void BotAimAtEnemy(bot_state_t *bs) {
if (VectorLength(dir) > 100) {
//check if the bot is visible from the ground target
trace.endpos[2] += 1;
BotAI_Trace(&trace, trace.endpos, NULL, NULL, entinfo.origin, entinfo.number, MASK_SHOT);
AI_main_BotAITrace(&trace, trace.endpos, NULL, NULL, entinfo.origin, entinfo.number, MASK_SHOT);
if (trace.fraction >= 1) {
//botimport.Print(PRT_MESSAGE, "%1.1f aiming at ground\n", AAS_Time());
VectorCopy(groundtarget, bestorigin);
@ -1842,7 +1842,7 @@ void BotAimAtEnemy(bot_state_t *bs) {
}
//
if (enemyvisible) {
BotAI_Trace(&trace, bs->eye, NULL, NULL, bestorigin, bs->entitynum, MASK_SHOT);
AI_main_BotAITrace(&trace, bs->eye, NULL, NULL, bestorigin, bs->entitynum, MASK_SHOT);
VectorCopy(trace.endpos, bs->aimtarget);
}
else {
@ -1924,7 +1924,7 @@ void BotCheckAttack(bot_state_t *bs) {
}
}
//
BotEntityInfo(bs->enemy, &entinfo);
AI_main_BotEntityInfo(bs->enemy, &entinfo);
VectorSubtract(entinfo.origin, bs->eye, dir);
//
if (VectorLength(dir) < 100) fov = 120;
@ -1937,7 +1937,7 @@ void BotCheckAttack(bot_state_t *bs) {
}*/
vectoangles(dir, angles);
if (!InFieldOfVision(bs->viewangles, fov, angles)) return;
BotAI_Trace(&bsptrace, bs->eye, NULL, NULL, bs->aimtarget, bs->client, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
AI_main_BotAITrace(&bsptrace, bs->eye, NULL, NULL, bs->aimtarget, bs->client, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
if (bsptrace.fraction < 1 && bsptrace.ent != bs->enemy) return;
//get the weapon info
@ -1953,7 +1953,7 @@ void BotCheckAttack(bot_state_t *bs) {
VectorMA(start, 1000, forward, end);
//a little back to make sure not inside a very close enemy
VectorMA(start, -12, forward, start);
BotAI_Trace(&trace, start, mins, maxs, end, bs->entitynum, MASK_SHOT);
AI_main_BotAITrace(&trace, start, mins, maxs, end, bs->entitynum, MASK_SHOT);
//if won't hit the enemy
if (trace.ent != bs->enemy) {
//if the entity is a client
@ -2041,7 +2041,7 @@ void BotMapScripts(bot_state_t *bs) {
if (i == bs->client) continue;
//
BotEntityInfo(i, &entinfo);
AI_main_BotEntityInfo(i, &entinfo);
//
if (!entinfo.valid) continue;
//if the enemy isn't dead and the enemy isn't the bot self
@ -2104,19 +2104,19 @@ int BotEntityToActivate(int entitynum) {
char targetname[10][128];
aas_entityinfo_t entinfo;
BotEntityInfo(entitynum, &entinfo);
AI_main_BotEntityInfo(entitynum, &entinfo);
Com_sprintf(model, sizeof( model ), "*%d", entinfo.modelindex);
for (ent = trap_AAS_NextBSPEntity(0); ent; ent = trap_AAS_NextBSPEntity(ent)) {
if (!trap_AAS_ValueForBSPEpairKey(ent, "model", tmpmodel, sizeof(tmpmodel))) continue;
if (!strcmp(model, tmpmodel)) break;
}
if (!ent) {
BotAI_Print(PRT_ERROR, "BotEntityToActivate: no entity found with model %s\n", model);
AI_main_BotAIPrint(PRT_ERROR, "BotEntityToActivate: no entity found with model %s\n", model);
return 0;
}
trap_AAS_ValueForBSPEpairKey(ent, "classname", classname, sizeof(classname));
if (!classname[0]) {
BotAI_Print(PRT_ERROR, "BotEntityToActivate: entity with model %s has no classname\n", model);
AI_main_BotAIPrint(PRT_ERROR, "BotEntityToActivate: entity with model %s has no classname\n", model);
return 0;
}
//if it is a door
@ -2129,7 +2129,7 @@ int BotEntityToActivate(int entitynum) {
//get the targetname so we can find an entity with a matching target
if (!trap_AAS_ValueForBSPEpairKey(ent, "targetname", targetname[0], sizeof(targetname[0]))) {
#ifdef OBSTACLEDEBUG
BotAI_Print(PRT_ERROR, "BotEntityToActivate: entity with model \"%s\" has no targetname\n", model);
AI_main_BotAIPrint(PRT_ERROR, "BotEntityToActivate: entity with model \"%s\" has no targetname\n", model);
#endif //OBSTACLEDEBUG
return 0;
}
@ -2144,12 +2144,12 @@ int BotEntityToActivate(int entitynum) {
}
}
if (!ent) {
BotAI_Print(PRT_ERROR, "BotEntityToActivate: no entity with target \"%s\"\n", targetname[i]);
AI_main_BotAIPrint(PRT_ERROR, "BotEntityToActivate: no entity with target \"%s\"\n", targetname[i]);
i--;
continue;
}
if (!trap_AAS_ValueForBSPEpairKey(ent, "classname", classname, sizeof(classname))) {
BotAI_Print(PRT_ERROR, "BotEntityToActivate: entity with target \"%s\" has no classname\n", targetname[i]);
AI_main_BotAIPrint(PRT_ERROR, "BotEntityToActivate: entity with target \"%s\" has no classname\n", targetname[i]);
continue;
}
if (!strcmp(classname, "func_button")) {
@ -2164,7 +2164,7 @@ int BotEntityToActivate(int entitynum) {
i--;
}
}
BotAI_Print(PRT_ERROR, "BotEntityToActivate: unknown activator with classname \"%s\"\n", classname);
AI_main_BotAIPrint(PRT_ERROR, "BotEntityToActivate: unknown activator with classname \"%s\"\n", classname);
return 0;
}
@ -2249,10 +2249,10 @@ void BotAIBlocked(bot_state_t *bs, bot_moveresult_t *moveresult, int activate) {
return;
}
//
BotEntityInfo(moveresult->blockentity, &entinfo);
AI_main_BotEntityInfo(moveresult->blockentity, &entinfo);
#ifdef OBSTACLEDEBUG
ClientName(bs->client, netname, sizeof(netname));
BotAI_Print(PRT_MESSAGE, "%s: I'm blocked by model %d\n", netname, entinfo.modelindex);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I'm blocked by model %d\n", netname, entinfo.modelindex);
#endif
//if blocked by a bsp model and the bot wants to activate it if possible
if (entinfo.modelindex > 0 && entinfo.modelindex <= max_bspmodelindex && activate) {
@ -2262,14 +2262,14 @@ void BotAIBlocked(bot_state_t *bs, bot_moveresult_t *moveresult, int activate) {
if (!ent) {
strcpy(classname, "");
#ifdef OBSTACLEDEBUG
BotAI_Print(PRT_MESSAGE, "%s: can't find activator for blocking entity\n", ClientName(bs->client, netname, sizeof(netname)));
AI_main_BotAIPrint(PRT_MESSAGE, "%s: can't find activator for blocking entity\n", ClientName(bs->client, netname, sizeof(netname)));
#endif
}
else {
trap_AAS_ValueForBSPEpairKey(ent, "classname", classname, sizeof(classname));
#ifdef OBSTACLEDEBUG
ClientName(bs->client, netname, sizeof(netname));
BotAI_Print(PRT_MESSAGE, "%s: I should activate %s\n", netname, classname);
AI_main_BotAIPrint(PRT_MESSAGE, "%s: I should activate %s\n", netname, classname);
#endif
}
if (!strcmp(classname, "func_button")) {
@ -2370,8 +2370,8 @@ void BotAIBlocked(bot_state_t *bs, bot_moveresult_t *moveresult, int activate) {
}
else {
#ifdef OBSTACLEDEBUG
if (!numareas) BotAI_Print(PRT_MESSAGE, "button not in an area\n");
else BotAI_Print(PRT_MESSAGE, "button area has no reachabilities\n");
if (!numareas) AI_main_BotAIPrint(PRT_MESSAGE, "button not in an area\n");
else AI_main_BotAIPrint(PRT_MESSAGE, "button area has no reachabilities\n");
#endif //OBSTACLEDEBUG
if (bs->ainode == AINode_Seek_NBG) bs->nbg_time = 0;
else if (bs->ainode == AINode_Seek_LTG) bs->ltg_time = 0;
@ -2523,16 +2523,16 @@ void BotCheckConsoleMessages(bot_state_t *bs) {
NULL, NULL,
NULL, NULL,
botname, netname)) {
BotAI_Print(PRT_MESSAGE, "------------------------\n");
AI_main_BotAIPrint(PRT_MESSAGE, "------------------------\n");
}
else {
BotAI_Print(PRT_MESSAGE, "**** no valid reply ****\n");
AI_main_BotAIPrint(PRT_MESSAGE, "**** no valid reply ****\n");
}
}
//if at a valid chat position and not chatting already
else if (bs->ainode != AINode_Stand && BotValidChatPosition(bs)) {
chat_reply = 0;
if (random() < 1.5 / (NumBots()+1) && random() < chat_reply) {
if (random() < 1.5 / (AI_main_NumBots()+1) && random() < chat_reply) {
//if bot replies with a chat message
if (trap_BotReplyChat(bs->cs, message, context, CONTEXT_REPLY,
NULL, NULL,
@ -2614,7 +2614,7 @@ void BotCheckEvents(bot_state_t *bs, entityState_t *state) {
case EV_GLOBAL_SOUND:
{
if (state->eventParm < 0 || state->eventParm > MAX_SOUNDS) {
BotAI_Print(PRT_ERROR, "EV_GLOBAL_SOUND: eventParm (%d) out of range\n", state->eventParm);
AI_main_BotAIPrint(PRT_ERROR, "EV_GLOBAL_SOUND: eventParm (%d) out of range\n", state->eventParm);
break;
}
else {
@ -2630,7 +2630,7 @@ void BotCheckEvents(bot_state_t *bs, entityState_t *state) {
case EV_TEAM_SOUND:
{
if (state->eventParm < 0 || state->eventParm > MAX_TEAM_SOUNDS) {
BotAI_Print(PRT_ERROR, "EV_TEAM_SOUND: eventParm (%d) out of range\n", state->eventParm);
AI_main_BotAIPrint(PRT_ERROR, "EV_TEAM_SOUND: eventParm (%d) out of range\n", state->eventParm);
break;
}
@ -2665,7 +2665,7 @@ void BotCheckEvents(bot_state_t *bs, entityState_t *state) {
//if this sound is played on the bot
if (state->number == bs->client) {
if (state->eventParm < 0 || state->eventParm > MAX_SOUNDS) {
BotAI_Print(PRT_ERROR, "EV_GENERAL_SOUND: eventParm (%d) out of range\n", state->eventParm);
AI_main_BotAIPrint(PRT_ERROR, "EV_GENERAL_SOUND: eventParm (%d) out of range\n", state->eventParm);
break;
}
//check out the sound
@ -2695,12 +2695,12 @@ void BotCheckSnapshot(bot_state_t *bs) {
//
ent = 0;
while( ( ent = BotAI_GetSnapshotEntity( bs->client, ent, &state ) ) != -1 ) {
while( ( ent = AI_main_BotAIGetSnapshotEntity( bs->client, ent, &state ) ) != -1 ) {
//check the entity state for events
BotCheckEvents(bs, &state);
}
//check the player state for events
BotAI_GetEntityState(bs->client, &state);
AI_main_BotAIGetEntityState(bs->client, &state);
//copy the player state events to the entity state
state.event = bs->cur_ps.externalEvent;
state.eventParm = bs->cur_ps.externalEventParm;
@ -2803,7 +2803,7 @@ void BotDeathmatchAI(bot_state_t *bs, float thinktime) {
trap_BotDumpAvoidGoals(bs->gs);
BotDumpNodeSwitches(bs);
ClientName(bs->client, name, sizeof(name));
BotAI_Print(PRT_ERROR, "%s at %1.1f switched more than %d AI nodes\n", name, trap_AAS_Time(), MAX_NODESWITCHES);
AI_main_BotAIPrint(PRT_ERROR, "%s at %1.1f switched more than %d AI nodes\n", name, trap_AAS_Time(), MAX_NODESWITCHES);
}
//
bs->lastframe_health = bs->inventory[INVENTORY_HEALTH];
@ -2831,9 +2831,9 @@ void BotSetupDeathmatchAI(void) {
//
if (gametype == GT_CTF) {
if (trap_BotGetLevelItemGoal(-1, "Red Flag", &ctf_redflag) < 0)
BotAI_Print(PRT_WARNING, "CTF without Red Flag\n");
AI_main_BotAIPrint(PRT_WARNING, "CTF without Red Flag\n");
if (trap_BotGetLevelItemGoal(-1, "Blue Flag", &ctf_blueflag) < 0)
BotAI_Print(PRT_WARNING, "CTF without Blue Flag\n");
AI_main_BotAIPrint(PRT_WARNING, "CTF without Blue Flag\n");
}
max_bspmodelindex = 0;

1024
code/game/ai_main.c
View File

File diff suppressed because it is too large Load Diff

332
code/game/ai_main.h
View File

@ -7,7 +7,7 @@
* desc: Quake3 bot AI
*
* $Archive: /StarTrek/Code-DM/game/ai_main.h $
* $Author: Jmonroe $
* $Author: Jmonroe $
* $Revision: 1 $
* $Modtime: 1/21/00 10:12p $
* $Date: 1/25/00 6:26p $
@ -17,30 +17,46 @@
#ifndef AI_MAIN_H_
#define AI_AMIN_H_
#include "ai_common.h"
#include "be_ai_goal.h"
#include "be_aas.h"
#include "botlib.h"
//some maxs
#define MAX_NETNAME 36
#define MAX_FILEPATH 144
//#define DEBUG
#define CTF
#define MAX_ITEMS 256
#define MAX_ITEMS 256
//bot flags
#define BFL_STRAFERIGHT 1 //!<strafe to the right
#define BFL_ATTACKED 2 //!<bot has attacked last ai frame
#define BFL_ATTACKJUMPED 4 //!<bot jumped during attack last frame
#define BFL_AIMATENEMY 8 //!<bot aimed at the enemy this frame
#define BFL_AVOIDRIGHT 16 //!<avoid obstacles by going to the right
#define BFL_IDEALVIEWSET 32 //!<bot has ideal view angles set
#define BFL_FIGHTSUICIDAL 64 //!<bot is in a suicidal fight
typedef enum {
BFL_STRAFERIGHT = 1, //!<strafe to the right
BFL_ATTACKED = 2, //!<bot has attacked last ai frame
BFL_ATTACKJUMPED = 4, //!<bot jumped during attack last frame
BFL_AIMATENEMY = 8, //!<bot aimed at the enemy this frame
BFL_AVOIDRIGHT = 16, //!<avoid obstacles by going to the right
BFL_IDEALVIEWSET = 32, //!<bot has ideal view angles set
BFL_FIGHTSUICIDAL = 64 //!<bot is in a suicidal fight
} BFL;
//long term goal types
#define LTG_TEAMHELP 1 //!<help a team mate
#define LTG_TEAMACCOMPANY 2 //!<accompany a team mate
#define LTG_DEFENDKEYAREA 3 //!<defend a key area
#define LTG_GETFLAG 4 //!<get the enemy flag
#define LTG_RUSHBASE 5 //!<rush to the base
#define LTG_RETURNFLAG 6 //!<return the flag
#define LTG_CAMP 7 //!<camp somewhere
#define LTG_CAMPORDER 8 //!<ordered to camp somewhere
#define LTG_PATROL 9 //!<patrol
#define LTG_GETITEM 10 //!<get an item
#define LTG_KILL 11 //!<kill someone
typedef enum {
LTG_TEAMHELP = 1, //!<help a team mate
LTG_TEAMACCOMPANY, //!<accompany a team mate
LTG_DEFENDKEYAREA, //!<defend a key area
LTG_GETFLAG, //!<get the enemy flag
LTG_RUSHBASE, //!<rush to the base
LTG_RETURNFLAG, //!<return the flag
LTG_CAMP, //!<camp somewhere
LTG_CAMPORDER, //!<ordered to camp somewhere
LTG_PATROL, //!<patrol
LTG_GETITEM, //!<get an item
LTG_KILL //!<kill someone
} LTG;
//some goal dedication times
#define TEAM_HELP_TIME 10 //!<1 minute teamplay help time
#define TEAM_ACCOMPANY_TIME 10 //!<10 minutes teamplay accompany time
@ -69,139 +85,137 @@
#define PRESENCE_CROUCH 4
//!check points
typedef struct bot_waypoint_s
{
int inuse;
typedef struct bot_waypoint_s {
int32_t inuse;
char name[32];
bot_goal_t goal;
struct bot_waypoint_s *next, *prev;
} bot_waypoint_t;
//!bot state
typedef struct bot_state_s
{
int inuse; //!<true if this state is used by a bot client
int botthink_residual; //!<residual for the bot thinks
int client; //!<client number of the bot
int entitynum; //!<entity number of the bot
typedef struct bot_state_s {
int32_t inuse; //!<true if this state is used by a bot client
int32_t botthink_residual; //!<residual for the bot thinks
int32_t client; //!<client number of the bot
int32_t entitynum; //!<entity number of the bot
playerState_t cur_ps; //!<current player state
int last_eFlags; //!<last ps flags
int32_t last_eFlags; //!<last ps flags
usercmd_t lastucmd; //!<usercmd from last frame
int entityeventTime[1024]; //!<last entity event time
int32_t entityeventTime[1024]; //!<last entity event time
//
bot_settings_t settings; //!<several bot settings
int (*ainode)(struct bot_state_s *bs); //!<current AI node
float thinktime; //!<time the bot thinks this frame
int(*ainode)(struct bot_state_s *bs); //!<current AI node
double thinktime; //!<time the bot thinks this frame
vec3_t origin; //!<origin of the bot
vec3_t velocity; //!<velocity of the bot
int presencetype; //!<presence type of the bot
int32_t presencetype; //!<presence type of the bot
vec3_t eye; //!<eye coordinates of the bot
int areanum; //!<the number of the area the bot is in
int inventory[MAX_ITEMS]; //!<string with items amounts the bot has
int tfl; //!<the travel flags the bot uses
int flags; //!<several flags
int respawn_wait; //!<wait until respawned
int lasthealth; //!<health value previous frame
int lastkilledplayer; //!<last killed player
int lastkilledby; //!<player that last killed this bot
int botdeathtype; //!<the death type of the bot
int enemydeathtype; //!<the death type of the enemy
int botsuicide; //!<true when the bot suicides
int enemysuicide; //!<true when the enemy of the bot suicides
int setupcount; //!<true when the bot has just been setup
int entergamechat; //!<true when the bot used an enter game chat
int num_deaths; //!<number of time this bot died
int num_kills; //!<number of kills of this bot
int revenge_enemy; //!<the revenge enemy
int revenge_kills; //!<number of kills the enemy made
int lastframe_health; //!<health value the last frame
int lasthitcount; //!<number of hits last frame
int chatto; //!<chat to all or team
float walker; //!<walker charactertic
float ltime; //!<local bot time
float entergame_time; //!<time the bot entered the game
float ltg_time; //!<long term goal time
float nbg_time; //!<nearby goal time
float respawn_time; //!<time the bot takes to respawn
float respawnchat_time; //!<time the bot started a chat during respawn
float chase_time; //!<time the bot will chase the enemy
float enemyvisible_time; //!<time the enemy was last visible
float check_time; //!<time to check for nearby items
float stand_time; //!<time the bot is standing still
float lastchat_time; //!<time the bot last selected a chat
float standfindenemy_time; //!<time to find enemy while standing
float attackstrafe_time; //!<time the bot is strafing in one dir
float attackcrouch_time; //!<time the bot will stop crouching
float attackchase_time; //!<time the bot chases during actual attack
float attackjump_time; //!<time the bot jumped during attack
float enemysight_time; //!<time before reacting to enemy
float enemydeath_time; //!<time the enemy died
float enemyposition_time; //!<time the position and velocity of the enemy were stored
float activate_time; //!<time to activate something
float activatemessage_time; //!<time to show activate message
float defendaway_time; //!<time away while defending
float defendaway_range; //!<max travel time away from defend area
float rushbaseaway_time; //!<time away from rushing to the base
float ctfroam_time; //!<time the bot is roaming in ctf
float killedenemy_time; //!<time the bot killed the enemy
float arrive_time; //!<time arrived (at companion)
float lastair_time; //!<last time the bot had air
float teleport_time; //!<last time the bot teleported
float camp_time; //!<last time camped
float camp_range; //!<camp range
float weaponchange_time; //!<time the bot started changing weapons
float firethrottlewait_time; //!<amount of time to wait
float firethrottleshoot_time; //!<amount of time to shoot
float notblocked_time; //!<last time the bot was not blocked
int32_t areanum; //!<the number of the area the bot is in
int32_t inventory[MAX_ITEMS]; //!<string with items amounts the bot has
int32_t tfl; //!<the travel flags the bot uses
int32_t flags; //!<several flags
int32_t respawn_wait; //!<wait until respawned
int32_t lasthealth; //!<health value previous frame
int32_t lastkilledplayer; //!<last killed player
int32_t lastkilledby; //!<player that last killed this bot
int32_t botdeathtype; //!<the death type of the bot
int32_t enemydeathtype; //!<the death type of the enemy
int32_t botsuicide; //!<true when the bot suicides
int32_t enemysuicide; //!<true when the enemy of the bot suicides
int32_t setupcount; //!<true when the bot has just been setup
int32_t entergamechat; //!<true when the bot used an enter game chat
int32_t num_deaths; //!<number of time this bot died
int32_t num_kills; //!<number of kills of this bot
int32_t revenge_enemy; //!<the revenge enemy
int32_t revenge_kills; //!<number of kills the enemy made
int32_t lastframe_health; //!<health value the last frame
int32_t lasthitcount; //!<number of hits last frame
int32_t chatto; //!<chat to all or team
double walker; //!<walker charactertic
double ltime; //!<local bot time
double entergame_time; //!<time the bot entered the game
double ltg_time; //!<long term goal time
double nbg_time; //!<nearby goal time
double respawn_time; //!<time the bot takes to respawn
double respawnchat_time; //!<time the bot started a chat during respawn
double chase_time; //!<time the bot will chase the enemy
double enemyvisible_time; //!<time the enemy was last visible
double check_time; //!<time to check for nearby items
double stand_time; //!<time the bot is standing still
double lastchat_time; //!<time the bot last selected a chat
double standfindenemy_time; //!<time to find enemy while standing
double attackstrafe_time; //!<time the bot is strafing in one dir
double attackcrouch_time; //!<time the bot will stop crouching
double attackchase_time; //!<time the bot chases during actual attack
double attackjump_time; //!<time the bot jumped during attack
double enemysight_time; //!<time before reacting to enemy
double enemydeath_time; //!<time the enemy died
double enemyposition_time; //!<time the position and velocity of the enemy were stored
double activate_time; //!<time to activate something
double activatemessage_time; //!<time to show activate message
double defendaway_time; //!<time away while defending
double defendaway_range; //!<max travel time away from defend area
double rushbaseaway_time; //!<time away from rushing to the base
double ctfroam_time; //!<time the bot is roaming in ctf
double killedenemy_time; //!<time the bot killed the enemy
double arrive_time; //!<time arrived (at companion)
double lastair_time; //!<last time the bot had air
double teleport_time; //!<last time the bot teleported
double camp_time; //!<last time camped
double camp_range; //!<camp range
double weaponchange_time; //!<time the bot started changing weapons
double firethrottlewait_time; //!<amount of time to wait
double firethrottleshoot_time; //!<amount of time to shoot
double notblocked_time; //!<last time the bot was not blocked
vec3_t aimtarget;
vec3_t enemyvelocity; //!<enemy velocity 0.5 secs ago during battle
vec3_t enemyorigin; //!<enemy origin 0.5 secs ago during battle
//
int character; //!<the bot character
int ms; //!<move state of the bot
int gs; //!<goal state of the bot
int cs; //!<chat state of the bot
int ws; //!<weapon state of the bot
int32_t character; //!<the bot character
int32_t ms; //!<move state of the bot
int32_t gs; //!<goal state of the bot
int32_t cs; //!<chat state of the bot
int32_t ws; //!<weapon state of the bot
//
int enemy; //!<enemy entity number
int lastenemyareanum; //!<last reachability area the enemy was in
int32_t enemy; //!<enemy entity number
int32_t lastenemyareanum; //!<last reachability area the enemy was in
vec3_t lastenemyorigin; //!<last origin of the enemy in the reachability area
int weaponnum; //!<current weapon number
int32_t weaponnum; //!<current weapon number
vec3_t viewangles; //!<current view angles
vec3_t ideal_viewangles; //!<ideal view angles
vec3_t viewanglespeed;
//
int ltgtype; //!<long term goal type
int32_t ltgtype; //!<long term goal type
//
int teammate; //!<team mate
int32_t teammate; //!<team mate
bot_goal_t teamgoal; //!<the team goal
float teammessage_time; //!<time to message team mates what the bot is doing
float teamgoal_time; //!<time to stop helping team mate
float teammatevisible_time; //!<last time the team mate was NOT visible
double teammessage_time; //!<time to message team mates what the bot is doing
double teamgoal_time; //!<time to stop helping team mate
double teammatevisible_time; //!<last time the team mate was NOT visible
//
int lead_teammate; //!<team mate the bot is leading
int32_t lead_teammate; //!<team mate the bot is leading
bot_goal_t lead_teamgoal; //!<team goal while leading
float lead_time; //!<time leading someone
float leadvisible_time; //!<last time the team mate was visible
float leadmessage_time; //!<last time a messaged was sent to the team mate
float leadbackup_time; //!<time backing up towards team mate
double lead_time; //!<time leading someone
double leadvisible_time; //!<last time the team mate was visible
double leadmessage_time; //!<last time a messaged was sent to the team mate
double leadbackup_time; //!<time backing up towards team mate
//
char teamleader[32]; //!<netname of the team leader
float askteamleader_time; //!<time asked for team leader
float becometeamleader_time; //!<time the bot will become the team leader
float teamgiveorders_time; //!<time to give team orders
float lastflagcapture_time; //!<last time a flag was captured
int numteammates; //!<number of team mates
int redflagstatus; //!<0 = at base, 1 = not at base
int blueflagstatus; //!<0 = at base, 1 = not at base
int flagstatuschanged; //!<flag status changed
int forceorders; //!<true if forced to give orders
int flagcarrier; //!<team mate carrying the enemy flag
int ctfstrategy; //!<ctf strategy
double askteamleader_time; //!<time asked for team leader
double becometeamleader_time; //!<time the bot will become the team leader
double teamgiveorders_time; //!<time to give team orders
double lastflagcapture_time; //!<last time a flag was captured
int32_t numteammates; //!<number of team mates
int32_t redflagstatus; //!<0 = at base, 1 = not at base
int32_t blueflagstatus; //!<0 = at base, 1 = not at base
int32_t flagstatuschanged; //!<flag status changed
int32_t forceorders; //!<true if forced to give orders
int32_t flagcarrier; //!<team mate carrying the enemy flag
int32_t ctfstrategy; //!<ctf strategy
char subteam[32]; //!<sub team name
float formation_dist; //!<formation team mate intervening space
double formation_dist; //!<formation team mate intervening space
char formation_teammate[16]; //!<netname of the team mate the bot uses for relative positioning
float formation_angle; //!<angle relative to the formation team mate
double formation_angle; //!<angle relative to the formation team mate
vec3_t formation_dir; //!<the direction the formation is moving in
vec3_t formation_origin; //!<origin the bot uses for relative positioning
bot_goal_t formation_goal; //!<formation goal
@ -209,24 +223,76 @@ typedef struct bot_state_s
bot_waypoint_t *checkpoints; //!<check points
bot_waypoint_t *patrolpoints; //!<patrol points
bot_waypoint_t *curpatrolpoint; //!<current patrol point the bot is going for
int patrolflags; //!<patrol flags
int32_t patrolflags; //!<patrol flags
} bot_state_t;
//!resets the whole bot state
void BotResetState(bot_state_t *bs);
void AI_main_BotResetState(bot_state_t *bs);
//!returns the number of bots in the game
int NumBots(void);
int32_t AI_main_NumBots(void);
//!returns info about the entity
void BotEntityInfo(int entnum, aas_entityinfo_t *info);
void AI_main_BotEntityInfo(int32_t entnum, aas_entityinfo_t *info);
// from the game source
void QDECL BotAI_Print(int type, char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
void QDECL QDECL BotAI_BotInitialChat( bot_state_t *bs, char *type, ... );
void BotAI_Trace(bsp_trace_t *bsptrace, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int passent, int contentmask);
int BotAI_GetClientState( int clientNum, playerState_t *state );
int BotAI_GetEntityState( int entityNum, entityState_t *state );
int BotAI_GetSnapshotEntity( int clientNum, int sequence, entityState_t *state );
int BotTeamLeader(bot_state_t *bs);
void QDECL AI_main_BotAIPrint(int32_t type, char *fmt, ...) __attribute__((format(printf, 2, 3)));
void QDECL QDECL AI_main_BotAIInitialChat(bot_state_t *bs, char *type, ...);
void AI_main_BotAITrace(bsp_trace_t *bsptrace, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int32_t passent, int32_t contentmask);
int32_t AI_main_BotAIGetClientState(int32_t clientNum, playerState_t *state);
int32_t AI_main_BotAIGetEntityState(int32_t entityNum, entityState_t *state);
int32_t AI_main_BotAIGetSnapshotEntity(int32_t clientNum, int32_t sequence, entityState_t *state);
int32_t AI_main_BotTeamLeader(bot_state_t *bs);
/**
* Setup bot AI.
*
* \param restart Determines if this is a map restart.
*/
int32_t AI_main_BotAISetup(int32_t restart);
/**
* Shutdown bot AI.
*
* \param restart Determines if this is a map restart.
*/
int32_t AI_main_BotAIShutdown(int32_t restart);
/**
* Load map in bot lib.
*
* \param restart Determines if this is a map restart.
*/
int32_t AI_main_BotAILoadMap(int32_t restart);
/**
* Setup bot AI for client.
*
* \param client client number
* \param settings bot settings
*/
int32_t AI_main_BotAISetupClient(int32_t client, bot_settings_t* settings);
/**
* Shutdown bot client.
*
* \param client client number
*/
int32_t AI_main_BotAIShutdownClient(int32_t client);
/**
* Star frame.
*
* \param time current time
*/
int32_t AI_main_BotAIStartFrame(int32_t time);
#endif /* AI_AMIN_H_ */

62
code/game/ai_team.c
View File

@ -91,7 +91,7 @@ int BotClientTravelTimeToGoal(int client, bot_goal_t *goal) {
playerState_t ps;
int areanum;
BotAI_GetClientState(client, &ps);
AI_main_BotAIGetClientState(client, &ps);
areanum = BotPointAreaNum(ps.origin);
if (!areanum) return 1;
return trap_AAS_AreaTravelTimeToGoalArea(areanum, ps.origin, goal->areanum, TFL_DEFAULT);
@ -259,7 +259,7 @@ void BotCTFOrders_BothFlagsNotAtBase(bot_state_t *bs) {
if (teammates[0] != bs->flagcarrier) other = teammates[0];
else other = teammates[1];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, other);
break;
}
@ -271,17 +271,17 @@ void BotCTFOrders_BothFlagsNotAtBase(bot_state_t *bs) {
ClientName(other, name, sizeof(name));
ClientName(bs->flagcarrier, carriername, sizeof(carriername));
if (bs->flagcarrier == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_accompanyme", name, NULL);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
AI_main_BotAIInitialChat(bs, "cmd_accompany", name, carriername, NULL);
}
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);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, other);
break;
}
@ -299,10 +299,10 @@ void BotCTFOrders_BothFlagsNotAtBase(bot_state_t *bs) {
//
ClientName(teammates[i], name, sizeof(name));
if (bs->flagcarrier == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_accompanyme", name, NULL);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
AI_main_BotAIInitialChat(bs, "cmd_accompany", name, carriername, NULL);
}
BotSayTeamOrder(bs, teammates[i]);
}
@ -313,7 +313,7 @@ void BotCTFOrders_BothFlagsNotAtBase(bot_state_t *bs) {
}
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
}
//
@ -343,11 +343,11 @@ void BotCTFOrders_FlagNotAtBase(bot_state_t *bs) {
{
//both will go for the enemy flag
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
//
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
break;
}
@ -355,15 +355,15 @@ void BotCTFOrders_FlagNotAtBase(bot_state_t *bs) {
{
//everyone go for the flag
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
//
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
//
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
break;
}
@ -376,13 +376,13 @@ void BotCTFOrders_FlagNotAtBase(bot_state_t *bs) {
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
}
//
@ -412,7 +412,7 @@ void BotCTFOrders_EnemyFlagNotAtBase(bot_state_t *bs) {
if (teammates[0] == bs->flagcarrier) other = teammates[1];
else other = teammates[0];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, other);
break;
}
@ -422,7 +422,7 @@ void BotCTFOrders_EnemyFlagNotAtBase(bot_state_t *bs) {
if (teammates[0] != bs->flagcarrier) other = teammates[0];
else other = teammates[1];
ClientName(other, name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, other);
//tell the one furthest from the base not carrying the flag to accompany the flag carrier
if (teammates[2] != bs->flagcarrier) other = teammates[2];
@ -430,10 +430,10 @@ void BotCTFOrders_EnemyFlagNotAtBase(bot_state_t *bs) {
ClientName(other, name, sizeof(name));
ClientName(bs->flagcarrier, carriername, sizeof(carriername));
if (bs->flagcarrier == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_accompanyme", name, NULL);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
AI_main_BotAIInitialChat(bs, "cmd_accompany", name, carriername, NULL);
}
BotSayTeamOrder(bs, other);
break;
@ -451,7 +451,7 @@ void BotCTFOrders_EnemyFlagNotAtBase(bot_state_t *bs) {
continue;
}
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
}
ClientName(bs->flagcarrier, carriername, sizeof(carriername));
@ -463,10 +463,10 @@ void BotCTFOrders_EnemyFlagNotAtBase(bot_state_t *bs) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
if (bs->flagcarrier == bs->client) {
BotAI_BotInitialChat(bs, "cmd_accompanyme", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_accompanyme", name, NULL);
}
else {
BotAI_BotInitialChat(bs, "cmd_accompany", name, carriername, NULL);
AI_main_BotAIInitialChat(bs, "cmd_accompany", name, carriername, NULL);
}
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
}
@ -500,11 +500,11 @@ void BotCTFOrders_BothFlagsAtBase(bot_state_t *bs) {
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
//the other will get the flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
break;
}
@ -512,15 +512,15 @@ void BotCTFOrders_BothFlagsAtBase(bot_state_t *bs) {
{
//the one closest to the base will defend the base
ClientName(teammates[0], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[0]);
//the others should go for the enemy flag
ClientName(teammates[1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[1]);
//
ClientName(teammates[2], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[2]);
break;
}
@ -532,13 +532,13 @@ void BotCTFOrders_BothFlagsAtBase(bot_state_t *bs) {
for (i = 0; i < defenders; i++) {
//
ClientName(teammates[i], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_defendbase", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_defendbase", name, NULL);
BotSayTeamOrder(bs, teammates[i]);
}
for (i = 0; i < attackers; i++) {
//
ClientName(teammates[numteammates - i - 1], name, sizeof(name));
BotAI_BotInitialChat(bs, "cmd_getflag", name, NULL);
AI_main_BotAIInitialChat(bs, "cmd_getflag", name, NULL);
BotSayTeamOrder(bs, teammates[numteammates - i - 1]);
}
//
@ -584,13 +584,13 @@ void BotTeamAI(bot_state_t *bs) {
}
if (bs->askteamleader_time && bs->askteamleader_time < trap_AAS_Time()) {
//if asked for a team leader and no repsonse
BotAI_BotInitialChat(bs, "whoisteamleader", NULL);
AI_main_BotAIInitialChat(bs, "whoisteamleader", NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
bs->askteamleader_time = 0;
bs->becometeamleader_time = trap_AAS_Time() + 15 + random() * 10;
}
if (bs->becometeamleader_time && bs->becometeamleader_time < trap_AAS_Time()) {
BotAI_BotInitialChat(bs, "iamteamleader", NULL);
AI_main_BotAIInitialChat(bs, "iamteamleader", NULL);
trap_BotEnterChat(bs->cs, bs->client, CHAT_TEAM);
ClientName(bs->client, netname, sizeof(netname));
strncpy(bs->teamleader, netname, sizeof(bs->teamleader));

4
code/game/g_active.c
View File

@ -1810,7 +1810,7 @@ static void ClientEvents( gentity_t *ent, int oldEventSequence ) {
}
void BotTestSolid(vec3_t origin);
void AI_main_BotTestSolid(vec3_t origin);
void G_ThrowWeapon( gentity_t *ent, char *txt )
{
@ -2172,7 +2172,7 @@ static void ClientThink_real( gentity_t *ent ) {
VectorCopy( ps->origin, ent->r.currentOrigin );
//test for solid areas in the AAS file
BotTestSolid(ent->r.currentOrigin);
AI_main_BotTestSolid(ent->r.currentOrigin);
// touch other objects
ClientImpacts( ent, &pm );

3
code/game/g_bot.c
View File

@ -6,6 +6,7 @@
#include "g_main.h"
#include "g_client.h"
#include "g_syscalls.h"
#include "ai_main.h"
static int32_t g_numBots;
@ -564,7 +565,7 @@ qboolean G_BotConnect( int32_t clientNum, qboolean restart ) {
strncpy( settings.team, Info_ValueForKey( userinfo, "team" ), sizeof(settings.team) );
strncpy( settings.pclass, Info_ValueForKey( userinfo, "class" ), sizeof(settings.pclass) );
if (BotAISetupClient( clientNum, &settings ) == 0) {
if (AI_main_BotAISetupClient( clientNum, &settings ) == 0) {
trap_DropClient( clientNum, "BotAISetupClient failed" );
return qfalse;
}

7
code/game/g_client.c
View File

@ -11,6 +11,11 @@
#include "g_lua.h"
#include "g_logger.h"
#include "g_syscalls.h"
#include "ai_common.h"
// predeclare ai main functions
extern int32_t AI_main_BotAISetupClient(int32_t client, bot_settings_t* settings);
extern int32_t AI_main_BotAIShutdownClient(int32_t client);
reconData_t g_reconData[MAX_RECON_NAMES]; //!< recon data for a limited ammount of clients
int32_t g_reconNum;
@ -2263,7 +2268,7 @@ void G_Client_Disconnect( int32_t clientNum ) {
G_Client_CalculateRanks( qfalse );
if ( (ent->r.svFlags & SVF_BOT) != 0 ) {
BotAIShutdownClient( clientNum );
AI_main_BotAIShutdownClient( clientNum );
}
// kef -- if this guy contributed to any of our kills/deaths/weapons logs, clean 'em out

64
code/game/g_local.h
View File

@ -1880,69 +1880,7 @@ void Svcmd_BotList_f( void );
*
* \todo Remove? We don't support bots.
*/
void BotInterbreedEndMatch( void );
// ai_main.c
//some maxs
#define MAX_NETNAME 36
#define MAX_FILEPATH 144
//bot settings
/** \struct bot_settings_t
* Containing settings for bots.
*/
typedef struct bot_settings_s
{
char characterfile[MAX_FILEPATH]; /*!< filename of character file */
int skill; /*!< skill level */
char team[MAX_FILEPATH]; /*!< team */
char pclass[MAX_FILEPATH]; /*!< class */
} bot_settings_t;
/**
* Setup bot AI.
*
* \param restart Determines if this is a map restart.
*/
int BotAISetup( int restart );
/**
* Shutdown bot AI.
*
* \param restart Determines if this is a map restart.
*/
int BotAIShutdown( int restart );
/**
* Load map in bot lib.
*
* \param restart Determines if this is a map restart.
*/
int BotAILoadMap( int restart );
/**
* Setup bot AI for client.
*
* \param client client number
* \param settings bot settings
*/
int BotAISetupClient( int client, bot_settings_t* settings );
/**
* Shutdown bot client.
*
* \param client client number
*/
int BotAIShutdownClient( int client );
/**
* Star frame.
*
* \param time current time
*/
int BotAIStartFrame( int time );
void AI_main_BotInterbreedEndMatch( void );
//
// g_lua.c

16
code/game/g_main.c
View File

@ -19,6 +19,12 @@
#include "g_weapon.h"
#include "g_syscalls.h"
// pre declare ai functions
extern int32_t AI_main_BotAIStartFrame(int32_t time);
extern int32_t AI_main_BotAISetup(int32_t restart);
extern int32_t AI_main_BotAIShutdown(int32_t restart);
extern int32_t AI_main_BotAILoadMap(int32_t restart);
extern void BG_LoadItemNames(void);
extern qboolean BG_ParseRankNames(char* fileName, rankNames_t rankNames[], size_t size);
@ -514,7 +520,7 @@ Q_EXPORT intptr_t vmMain(int command, int arg0, int arg1, int arg2, /*@unused@*/
//RPG-X : TiM - plagiarised Red's logic from SFEFMOD here lol
return (intptr_t)ConsoleCommand();
case BOTAI_START_FRAME:
return (intptr_t)BotAIStartFrame(arg0);
return (intptr_t)AI_main_BotAIStartFrame(arg0);
}
return -1;
@ -1872,8 +1878,8 @@ void G_InitGame(int levelTime, unsigned int randomSeed, int restart) {
}
if (trap_Cvar_VariableIntegerValue("bot_enable") != 0) {
BotAISetup(restart);
BotAILoadMap(restart);
AI_main_BotAISetup(restart);
AI_main_BotAILoadMap(restart);
G_InitBots((qboolean)restart);
}
@ -1980,7 +1986,7 @@ void G_ShutdownGame(int restart) {
G_WriteSessionData();
if (trap_Cvar_VariableIntegerValue("bot_enable") != 0) {
BotAIShutdown(restart);
AI_main_BotAIShutdown(restart);
}
if (level.timedMessages != NULL) {
@ -2271,7 +2277,7 @@ void ExitLevel(void) {
levelExiting = qtrue;
//bot interbreeding
BotInterbreedEndMatch();
AI_main_BotInterbreedEndMatch();
G_ClearObjectives();
// if we are running a tournement map, kick the loser to spectator status,

1
code/game/game.vcxproj
View File

@ -484,6 +484,7 @@
<ClInclude Include="..\qcommon\stv_version.h" />
<ClInclude Include="ai_chat.h" />
<ClInclude Include="ai_cmd.h" />
<ClInclude Include="ai_common.h" />
<ClInclude Include="ai_dmnet.h" />
<ClInclude Include="ai_dmq3.h" />
<ClInclude Include="ai_main.h" />

3
code/game/game.vcxproj.filters
View File

@ -539,6 +539,9 @@
<ClInclude Include="g_syscalls.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="ai_common.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="game.def">