mirror of
https://github.com/ineedbots/t6_bot_warfare.git
synced 2025-04-21 17:35:42 +00:00
2230 lines
43 KiB
Plaintext
2230 lines
43 KiB
Plaintext
/*
|
|
_bot
|
|
Author: INeedGames
|
|
Date: 06/19/2021
|
|
The entry point and manager of the bots.
|
|
*/
|
|
|
|
#include maps\mp\gametypes\_globallogic_utils;
|
|
#include maps\mp\_utility;
|
|
#include common_scripts\utility;
|
|
|
|
/*
|
|
Replace func stuff
|
|
*/
|
|
main()
|
|
{
|
|
level.bw_VERSION = "1.1.1";
|
|
|
|
if ( getDvar( "bots_main" ) == "" )
|
|
setDvar( "bots_main", true );
|
|
|
|
if ( !getDvarInt( "bots_main" ) )
|
|
return;
|
|
|
|
if ( !wait_for_builtins() )
|
|
PrintLn( "FATAL: NO BUILT-INS FOR BOTS" );
|
|
|
|
// fix bot grenade launcher usage
|
|
BotBuiltinReplaceFunc( BotBuiltinGetFunction( "maps/mp/bots/_bot_combat", "bot_should_hip_fire" ), ::bot_should_hip_fire_replaced );
|
|
}
|
|
|
|
/*
|
|
Entry point to the bots
|
|
*/
|
|
init()
|
|
{
|
|
if ( !getDvarInt( "bots_main" ) )
|
|
return;
|
|
|
|
if ( !wait_for_builtins() )
|
|
PrintLn( "FATAL: NO BUILT-INS FOR BOTS" );
|
|
|
|
if ( getDvar( "bots_main_GUIDs" ) == "" )
|
|
setDvar( "bots_main_GUIDs", "" ); //guids of players who will be given host powers, comma seperated
|
|
|
|
if ( getDvar( "bots_main_firstIsHost" ) == "" )
|
|
setDvar( "bots_main_firstIsHost", false ); //first play to connect is a host
|
|
|
|
if ( getDvar( "bots_main_kickBotsAtEnd" ) == "" )
|
|
setDvar( "bots_main_kickBotsAtEnd", false ); //kicks the bots at game end (dedis hang with bots on map rotate)
|
|
|
|
if ( getDvar( "bots_main_waitForHostTime" ) == "" )
|
|
setDvar( "bots_main_waitForHostTime", 10.0 ); //how long to wait to wait for the host player
|
|
|
|
if ( getDvar( "bots_manage_add" ) == "" )
|
|
setDvar( "bots_manage_add", 0 ); //amount of bots to add to the game
|
|
|
|
if ( getDvar( "bots_manage_fill" ) == "" )
|
|
setDvar( "bots_manage_fill", 0 ); //amount of bots to maintain
|
|
|
|
if ( getDvar( "bots_manage_fill_spec" ) == "" )
|
|
setDvar( "bots_manage_fill_spec", true ); //to count for fill if player is on spec team
|
|
|
|
if ( getDvar( "bots_manage_fill_mode" ) == "" )
|
|
setDvar( "bots_manage_fill_mode", 0 ); //fill mode, 0 adds everyone, 1 just bots, 2 maintains at maps, 3 is 2 with 1
|
|
|
|
if ( getDvar( "bots_manage_fill_kick" ) == "" )
|
|
setDvar( "bots_manage_fill_kick", false ); //kick bots if too many
|
|
|
|
if ( getDvar( "bots_skill" ) == "" ) // alias for bot_difficulty
|
|
setDvar( "bots_skill", "" );
|
|
|
|
if ( getDvar( "bots_team" ) == "" )
|
|
setDvar( "bots_team", "autoassign" ); //which team for bots to join
|
|
|
|
if ( getDvar( "bots_team_amount" ) == "" )
|
|
setDvar( "bots_team_amount", 0 ); //amount of bots on axis team
|
|
|
|
if ( getDvar( "bots_team_force" ) == "" )
|
|
setDvar( "bots_team_force", false ); //force bots on team
|
|
|
|
if ( getDvar( "bots_team_mode" ) == "" )
|
|
setDvar( "bots_team_mode", 0 ); //counts just bots when 1
|
|
|
|
if ( getDvar( "bots_loadout_rank" ) == "" ) // what rank the bots should be around, -1 is around the players, 0 is all random
|
|
setDvar( "bots_loadout_rank", -1 );
|
|
|
|
if ( getDvar( "bots_loadout_prestige" ) == "" ) // what pretige the bots will be, -1 is the players, -2 is random
|
|
setDvar( "bots_loadout_prestige", -1 );
|
|
|
|
if ( getDvar( "bots_play_nade" ) == "" )
|
|
setDvar( "bots_play_nade", true );
|
|
|
|
if ( getDvar( "bots_play_aim" ) == "" )
|
|
setDvar( "bots_play_aim", true );
|
|
|
|
if ( getDvar( "bots_play_jumpdrop" ) == "" ) //bots jump and dropshot
|
|
setDvar( "bots_play_jumpdrop", true );
|
|
|
|
if ( !isDefined( game["botWarfare"] ) )
|
|
game["botWarfare"] = true;
|
|
|
|
thread fixGamemodes();
|
|
|
|
thread onPlayerConnect();
|
|
|
|
thread handleBots();
|
|
}
|
|
|
|
/*
|
|
Fixes gl usage
|
|
*/
|
|
bot_should_hip_fire_replaced()
|
|
{
|
|
weapon = self getcurrentweapon();
|
|
class = weaponclass( weapon );
|
|
|
|
if ( class == "grenade" )
|
|
return 1;
|
|
|
|
func = BotBuiltinGetFunction( "maps/mp/bots/_bot_combat", "bot_should_hip_fire" );
|
|
BotBuiltinDisableDetourOnce( func );
|
|
return self [[ func ]]();
|
|
}
|
|
|
|
/*
|
|
Adds sd to bot logic
|
|
*/
|
|
fixGamemodes()
|
|
{
|
|
wait 0.25;
|
|
|
|
if ( level.gametype == "sd" )
|
|
level.bot_gametype = ::bot_sd_think;
|
|
}
|
|
|
|
/*
|
|
Starts the threads for bots.
|
|
*/
|
|
handleBots()
|
|
{
|
|
thread diffBots();
|
|
thread teamBots();
|
|
addBots();
|
|
|
|
while ( !level.intermission )
|
|
wait 0.05;
|
|
|
|
setDvar( "bots_manage_add", getBotArray().size );
|
|
|
|
if ( !getDvarInt( "bots_main_kickBotsAtEnd" ) )
|
|
return;
|
|
|
|
bots = getBotArray();
|
|
|
|
for ( i = 0; i < bots.size; i++ )
|
|
{
|
|
bot = bots[i];
|
|
|
|
if ( isDefined( bot ) )
|
|
kick( bot getEntityNumber() );
|
|
}
|
|
}
|
|
|
|
/*
|
|
Handles the diff of the bots
|
|
*/
|
|
diffBots()
|
|
{
|
|
for ( ;; )
|
|
{
|
|
wait 1.5;
|
|
|
|
// we dont use 'bots_skill' so that we can still use the .menu dvar
|
|
|
|
if ( getDvar( "bots_skill" ) != "" )
|
|
{
|
|
SetDvar( "bot_difficulty", getDvar( "bots_skill" ) );
|
|
setDvar( "bots_skill", "" );
|
|
}
|
|
|
|
bot_set_difficulty( getdvarint( "bot_difficulty" ) );
|
|
}
|
|
}
|
|
|
|
/*
|
|
Sets the difficulty of the bots
|
|
*/
|
|
bot_set_difficulty( difficulty )
|
|
{
|
|
if ( difficulty == 3 )
|
|
{
|
|
setdvar( "bot_MinDeathTime", "250" );
|
|
setdvar( "bot_MaxDeathTime", "500" );
|
|
setdvar( "bot_MinFireTime", "100" );
|
|
setdvar( "bot_MaxFireTime", "250" );
|
|
setdvar( "bot_PitchUp", "-5" );
|
|
setdvar( "bot_PitchDown", "10" );
|
|
setdvar( "bot_Fov", "160" );
|
|
setdvar( "bot_MinAdsTime", "3000" );
|
|
setdvar( "bot_MaxAdsTime", "5000" );
|
|
setdvar( "bot_MinCrouchTime", "100" );
|
|
setdvar( "bot_MaxCrouchTime", "400" );
|
|
setdvar( "bot_TargetLeadBias", "2" );
|
|
setdvar( "bot_MinReactionTime", "40" );
|
|
setdvar( "bot_MaxReactionTime", "70" );
|
|
setdvar( "bot_StrafeChance", "1" );
|
|
setdvar( "bot_MinStrafeTime", "3000" );
|
|
setdvar( "bot_MaxStrafeTime", "6000" );
|
|
setdvar( "scr_help_dist", "512" );
|
|
setdvar( "bot_AllowGrenades", "1" );
|
|
setdvar( "bot_MinGrenadeTime", "1500" );
|
|
setdvar( "bot_MaxGrenadeTime", "4000" );
|
|
setdvar( "bot_MeleeDist", "70" );
|
|
setdvar( "bot_YawSpeed", "2" );
|
|
}
|
|
else if ( difficulty == 2 )
|
|
{
|
|
setdvar( "bot_MinDeathTime", "250" );
|
|
setdvar( "bot_MaxDeathTime", "500" );
|
|
setdvar( "bot_MinFireTime", "400" );
|
|
setdvar( "bot_MaxFireTime", "600" );
|
|
setdvar( "bot_PitchUp", "-5" );
|
|
setdvar( "bot_PitchDown", "10" );
|
|
setdvar( "bot_Fov", "100" );
|
|
setdvar( "bot_MinAdsTime", "3000" );
|
|
setdvar( "bot_MaxAdsTime", "5000" );
|
|
setdvar( "bot_MinCrouchTime", "100" );
|
|
setdvar( "bot_MaxCrouchTime", "400" );
|
|
setdvar( "bot_TargetLeadBias", "2" );
|
|
setdvar( "bot_MinReactionTime", "400" );
|
|
setdvar( "bot_MaxReactionTime", "700" );
|
|
setdvar( "bot_StrafeChance", "0.9" );
|
|
setdvar( "bot_MinStrafeTime", "3000" );
|
|
setdvar( "bot_MaxStrafeTime", "6000" );
|
|
setdvar( "scr_help_dist", "384" );
|
|
setdvar( "bot_AllowGrenades", "1" );
|
|
setdvar( "bot_MinGrenadeTime", "1500" );
|
|
setdvar( "bot_MaxGrenadeTime", "4000" );
|
|
setdvar( "bot_MeleeDist", "70" );
|
|
setdvar( "bot_YawSpeed", "1.4" );
|
|
}
|
|
else if ( difficulty == 0 )
|
|
{
|
|
setdvar( "bot_MinDeathTime", "1000" );
|
|
setdvar( "bot_MaxDeathTime", "2000" );
|
|
setdvar( "bot_MinFireTime", "900" );
|
|
setdvar( "bot_MaxFireTime", "1000" );
|
|
setdvar( "bot_PitchUp", "-20" );
|
|
setdvar( "bot_PitchDown", "40" );
|
|
setdvar( "bot_Fov", "50" );
|
|
setdvar( "bot_MinAdsTime", "3000" );
|
|
setdvar( "bot_MaxAdsTime", "5000" );
|
|
setdvar( "bot_MinCrouchTime", "4000" );
|
|
setdvar( "bot_MaxCrouchTime", "6000" );
|
|
setdvar( "bot_TargetLeadBias", "8" );
|
|
setdvar( "bot_MinReactionTime", "1200" );
|
|
setdvar( "bot_MaxReactionTime", "1600" );
|
|
setdvar( "bot_StrafeChance", "0.1" );
|
|
setdvar( "bot_MinStrafeTime", "3000" );
|
|
setdvar( "bot_MaxStrafeTime", "6000" );
|
|
setdvar( "scr_help_dist", "256" );
|
|
setdvar( "bot_AllowGrenades", "0" );
|
|
setdvar( "bot_MeleeDist", "40" );
|
|
}
|
|
else
|
|
{
|
|
if ( difficulty != 1 )
|
|
return;
|
|
|
|
setdvar( "bot_MinDeathTime", "500" );
|
|
setdvar( "bot_MaxDeathTime", "1000" );
|
|
setdvar( "bot_MinFireTime", "600" );
|
|
setdvar( "bot_MaxFireTime", "800" );
|
|
setdvar( "bot_PitchUp", "-10" );
|
|
setdvar( "bot_PitchDown", "20" );
|
|
setdvar( "bot_Fov", "70" );
|
|
setdvar( "bot_MinAdsTime", "3000" );
|
|
setdvar( "bot_MaxAdsTime", "5000" );
|
|
setdvar( "bot_MinCrouchTime", "2000" );
|
|
setdvar( "bot_MaxCrouchTime", "4000" );
|
|
setdvar( "bot_TargetLeadBias", "4" );
|
|
setdvar( "bot_MinReactionTime", "600" );
|
|
setdvar( "bot_MaxReactionTime", "800" );
|
|
setdvar( "bot_StrafeChance", "0.6" );
|
|
setdvar( "bot_MinStrafeTime", "3000" );
|
|
setdvar( "bot_MaxStrafeTime", "6000" );
|
|
setdvar( "scr_help_dist", "256" );
|
|
setdvar( "bot_AllowGrenades", "1" );
|
|
setdvar( "bot_MinGrenadeTime", "1500" );
|
|
setdvar( "bot_MaxGrenadeTime", "4000" );
|
|
setdvar( "bot_MeleeDist", "70" );
|
|
setdvar( "bot_YawSpeed", "1.2" );
|
|
}
|
|
|
|
if ( level.gametype == "oic" && difficulty == 3 )
|
|
{
|
|
setdvar( "bot_MinReactionTime", "400" );
|
|
setdvar( "bot_MaxReactionTime", "500" );
|
|
setdvar( "bot_MinAdsTime", "1000" );
|
|
setdvar( "bot_MaxAdsTime", "2000" );
|
|
}
|
|
|
|
if ( ( difficulty == 2 || difficulty == 3 ) && level.gametype == "oic" )
|
|
{
|
|
setdvar( "bot_SprintDistance", "256" );
|
|
}
|
|
|
|
if ( !getDvarInt( "bots_play_nade" ) )
|
|
SetDvar( "bot_AllowGrenades", "0" );
|
|
|
|
if ( !getDvarInt( "bots_play_aim" ) )
|
|
{
|
|
setdvar( "bot_YawSpeed", "0" );
|
|
setdvar( "bot_PitchUp", "0" );
|
|
setdvar( "bot_PitchDown", "0" );
|
|
}
|
|
|
|
setDvar( "bot_difficulty", difficulty );
|
|
level.bot_difficulty = undefined;
|
|
level maps\mp\bots\_bot::bot_get_difficulty();
|
|
}
|
|
|
|
/*
|
|
A server thread for monitoring all bot's teams for custom server settings.
|
|
*/
|
|
teamBots_loop()
|
|
{
|
|
teamAmount = getDvarInt( "bots_team_amount" );
|
|
toTeam = getDvar( "bots_team" );
|
|
|
|
alliesbots = 0;
|
|
alliesplayers = 0;
|
|
axisbots = 0;
|
|
axisplayers = 0;
|
|
|
|
playercount = level.players.size;
|
|
|
|
for ( i = 0; i < playercount; i++ )
|
|
{
|
|
player = level.players[i];
|
|
|
|
if ( isDefined( player ) && isDefined( player.team ) )
|
|
{
|
|
if ( player is_bot() )
|
|
{
|
|
if ( player.pers["team"] == "allies" )
|
|
alliesbots++;
|
|
else if ( player.pers["team"] == "axis" )
|
|
axisbots++;
|
|
}
|
|
else
|
|
{
|
|
if ( player.pers["team"] == "allies" )
|
|
alliesplayers++;
|
|
else if ( player.pers["team"] == "axis" )
|
|
axisplayers++;
|
|
}
|
|
}
|
|
}
|
|
|
|
allies = alliesbots;
|
|
axis = axisbots;
|
|
|
|
if ( !getDvarInt( "bots_team_mode" ) )
|
|
{
|
|
allies += alliesplayers;
|
|
axis += axisplayers;
|
|
}
|
|
|
|
if ( toTeam != "custom" )
|
|
{
|
|
if ( getDvarInt( "bots_team_force" ) )
|
|
{
|
|
if ( toTeam == "autoassign" )
|
|
{
|
|
if ( abs( axis - allies ) > 1 )
|
|
{
|
|
toTeam = "axis";
|
|
|
|
if ( axis > allies )
|
|
toTeam = "allies";
|
|
}
|
|
}
|
|
|
|
if ( toTeam != "autoassign" )
|
|
{
|
|
playercount = level.players.size;
|
|
|
|
for ( i = 0; i < playercount; i++ )
|
|
{
|
|
player = level.players[i];
|
|
|
|
if ( isDefined( player ) && isDefined( player.team ) && player is_bot() && ( player.pers["team"] != toTeam ) )
|
|
{
|
|
if ( toTeam == "allies" )
|
|
player thread [[level.teammenu]]( "allies" );
|
|
else if ( toTeam == "axis" )
|
|
player thread [[level.teammenu]]( "axis" );
|
|
else
|
|
player thread [[level.spectator]]();
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
playercount = level.players.size;
|
|
|
|
for ( i = 0; i < playercount; i++ )
|
|
{
|
|
player = level.players[i];
|
|
|
|
if ( isDefined( player ) && isDefined( player.team ) && player is_bot() )
|
|
{
|
|
if ( player.pers["team"] == "axis" )
|
|
{
|
|
if ( axis > teamAmount )
|
|
{
|
|
player thread [[level.teammenu]]( "allies" );
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( axis < teamAmount )
|
|
{
|
|
player thread [[level.teammenu]]( "axis" );
|
|
break;
|
|
}
|
|
else if ( player.pers["team"] != "allies" )
|
|
{
|
|
player thread [[level.teammenu]]( "allies" );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
A server thread for monitoring all bot's teams for custom server settings.
|
|
*/
|
|
teamBots()
|
|
{
|
|
for ( ;; )
|
|
{
|
|
wait 1.5;
|
|
teamBots_loop();
|
|
}
|
|
}
|
|
|
|
/*
|
|
Loop
|
|
*/
|
|
addBots_loop()
|
|
{
|
|
botsToAdd = GetDvarInt( "bots_manage_add" );
|
|
|
|
if ( botsToAdd > 0 )
|
|
{
|
|
SetDvar( "bots_manage_add", 0 );
|
|
|
|
if ( botsToAdd > 64 )
|
|
botsToAdd = 64;
|
|
|
|
for ( ; botsToAdd > 0; botsToAdd-- )
|
|
{
|
|
level add_bot();
|
|
wait 0.5;
|
|
}
|
|
}
|
|
|
|
fillMode = getDVarInt( "bots_manage_fill_mode" );
|
|
|
|
if ( fillMode == 2 || fillMode == 3 )
|
|
setDvar( "bots_manage_fill", getGoodMapAmount() );
|
|
|
|
fillAmount = getDvarInt( "bots_manage_fill" );
|
|
|
|
players = 0;
|
|
bots = 0;
|
|
spec = 0;
|
|
|
|
playercount = level.players.size;
|
|
|
|
for ( i = 0; i < playercount; i++ )
|
|
{
|
|
player = level.players[i];
|
|
|
|
if ( isDefined( player ) )
|
|
{
|
|
if ( player is_bot() )
|
|
bots++;
|
|
else if ( !isDefined( player.team ) )
|
|
spec++;
|
|
else if ( player.pers["team"] != "axis" && player.pers["team"] != "allies" ) // dude this compiler is kekware
|
|
spec++;
|
|
else
|
|
players++;
|
|
}
|
|
}
|
|
|
|
if ( fillMode == 4 )
|
|
{
|
|
axisplayers = 0;
|
|
alliesplayers = 0;
|
|
|
|
playercount = level.players.size;
|
|
|
|
for ( i = 0; i < playercount; i++ )
|
|
{
|
|
player = level.players[i];
|
|
|
|
if ( isDefined( player ) && isDefined( player.team ) && !player is_bot() )
|
|
{
|
|
if ( player.pers["team"] == "axis" )
|
|
axisplayers++;
|
|
else if ( player.pers["team"] == "allies" )
|
|
alliesplayers++;
|
|
}
|
|
}
|
|
|
|
result = fillAmount - abs( axisplayers - alliesplayers ) + bots;
|
|
|
|
if ( players == 0 )
|
|
{
|
|
if ( bots < fillAmount )
|
|
result = fillAmount - 1;
|
|
else if ( bots > fillAmount )
|
|
result = fillAmount + 1;
|
|
else
|
|
result = fillAmount;
|
|
}
|
|
|
|
bots = result;
|
|
}
|
|
|
|
if ( !randomInt( 999 ) )
|
|
{
|
|
setDvar( "testclients_doreload", true );
|
|
wait 0.1;
|
|
setDvar( "testclients_doreload", false );
|
|
doExtraCheck();
|
|
}
|
|
|
|
amount = bots;
|
|
|
|
if ( fillMode == 0 || fillMode == 2 )
|
|
amount += players;
|
|
|
|
if ( getDVarInt( "bots_manage_fill_spec" ) )
|
|
amount += spec;
|
|
|
|
if ( amount < fillAmount )
|
|
setDvar( "bots_manage_add", 1 );
|
|
else if ( amount > fillAmount && getDvarInt( "bots_manage_fill_kick" ) )
|
|
{
|
|
tempBot = getBotToKick();
|
|
|
|
if ( isDefined( tempBot ) )
|
|
kick( tempBot getEntityNumber() );
|
|
}
|
|
}
|
|
|
|
/*
|
|
A server thread for monitoring all bot's in game. Will add and kick bots according to server settings.
|
|
*/
|
|
addBots()
|
|
{
|
|
level endon ( "game_ended" );
|
|
|
|
bot_wait_for_host();
|
|
|
|
for ( ;; )
|
|
{
|
|
wait 1.5;
|
|
|
|
addBots_loop();
|
|
}
|
|
}
|
|
|
|
/*
|
|
Adds a bot to the game.
|
|
*/
|
|
add_bot()
|
|
{
|
|
bot = addtestclient();
|
|
|
|
if ( isdefined( bot ) )
|
|
{
|
|
bot.pers["isBot"] = true;
|
|
bot.pers["isBotWarfare"] = true;
|
|
bot thread added();
|
|
}
|
|
}
|
|
|
|
/*
|
|
Player connects
|
|
*/
|
|
onPlayerConnect()
|
|
{
|
|
for ( ;; )
|
|
{
|
|
level waittill( "connected", player );
|
|
|
|
player thread connected();
|
|
}
|
|
}
|
|
|
|
/*
|
|
Connects
|
|
*/
|
|
connected()
|
|
{
|
|
self endon( "disconnect" );
|
|
|
|
if ( !isDefined( self.pers ) || !isDefined( self.pers["bot_host"] ) )
|
|
self thread doHostCheck();
|
|
|
|
if ( !self istestclient() )
|
|
return;
|
|
|
|
if ( !isDefined( self.pers["isBot"] ) )
|
|
{
|
|
self.pers["isBot"] = true;
|
|
}
|
|
|
|
if ( !isDefined( self.pers["isBotWarfare"] ) )
|
|
{
|
|
self.pers["isBotWarfare"] = true;
|
|
self thread added();
|
|
}
|
|
|
|
self thread teamWatch();
|
|
self thread classWatch();
|
|
self thread onBotSpawned();
|
|
|
|
self thread setRanks();
|
|
|
|
self thread watchBotDebugEvent();
|
|
}
|
|
|
|
/*
|
|
DEBUG
|
|
*/
|
|
watchBotDebugEvent()
|
|
{
|
|
self endon( "disconnect" );
|
|
|
|
for ( ;; )
|
|
{
|
|
self waittill( "bot_event", msg, str, b, c, d, e, f, g );
|
|
|
|
if ( GetDvarInt( "bots_main_debug" ) >= 2 )
|
|
{
|
|
big_str = "Bot Warfare debug: " + self.name + ": " + msg;
|
|
|
|
if ( isDefined( str ) && isString( str ) )
|
|
big_str += ", " + str;
|
|
|
|
if ( isDefined( b ) && isString( b ) )
|
|
big_str += ", " + b;
|
|
|
|
if ( isDefined( c ) && isString( c ) )
|
|
big_str += ", " + c;
|
|
|
|
if ( isDefined( d ) && isString( d ) )
|
|
big_str += ", " + d;
|
|
|
|
if ( isDefined( e ) && isString( e ) )
|
|
big_str += ", " + e;
|
|
|
|
if ( isDefined( f ) && isString( f ) )
|
|
big_str += ", " + f;
|
|
|
|
if ( isDefined( g ) && isString( g ) )
|
|
big_str += ", " + g;
|
|
|
|
BotBuiltinPrintConsole( big_str );
|
|
}
|
|
else if ( msg == "debug" && GetDvarInt( "bots_main_debug" ) )
|
|
{
|
|
BotBuiltinPrintConsole( "Bot Warfare debug: " + self.name + ": " + str );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
When the bot spawns
|
|
*/
|
|
onBotSpawned()
|
|
{
|
|
self endon( "disconnect" );
|
|
|
|
for ( ;; )
|
|
{
|
|
self waittill( "spawned_player" );
|
|
self BotBuiltinClearOverrides( true );
|
|
self BotBuiltinWeaponOverride( self getCurrentWeapon() );
|
|
|
|
self thread watch_for_override_stuff();
|
|
self thread watch_for_melee_override();
|
|
self thread bot_watch_think_mw2();
|
|
self BotNotifyBotEvent( "debug", "we spawned!" );
|
|
|
|
waittillframeend;
|
|
|
|
self.bot_first_spawn = undefined;
|
|
|
|
if ( randomInt( 100 ) < 2 )
|
|
self.bot_change_class = undefined;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Gets a GL
|
|
*/
|
|
getValidTube()
|
|
{
|
|
weaps = self getweaponslist( true );
|
|
|
|
for ( i = 0; i < weaps.size; i++ )
|
|
{
|
|
weap = weaps[i];
|
|
|
|
if ( !self GetAmmoCount( weap ) )
|
|
continue;
|
|
|
|
if ( !isstrstart( weap, "gl_" ) )
|
|
continue;
|
|
|
|
return weap;
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
/*
|
|
Bots play mw2
|
|
*/
|
|
bot_watch_think_mw2()
|
|
{
|
|
self endon( "disconnect" );
|
|
self endon( "death" );
|
|
level endon( "game_ended" );
|
|
|
|
for ( ;; )
|
|
{
|
|
wait randomIntRange( 1, 4 );
|
|
|
|
if ( self IsRemoteControlling() )
|
|
continue;
|
|
|
|
if ( self maps\mp\bots\_bot_combat::bot_has_enemy() )
|
|
continue;
|
|
|
|
tube = self getValidTube();
|
|
|
|
if ( !isDefined( tube ) )
|
|
{
|
|
if ( self GetAmmoCount( "usrpg_mp" ) )
|
|
tube = "usrpg_mp";
|
|
else if ( self GetAmmoCount( "smaw_mp" ) )
|
|
tube = "smaw_mp";
|
|
else
|
|
return;
|
|
}
|
|
|
|
if ( self GetCurrentWeapon() == tube )
|
|
return;
|
|
|
|
if ( randomInt( 100 ) > 35 )
|
|
return;
|
|
|
|
self switchtoweapon( tube );
|
|
}
|
|
}
|
|
|
|
/*
|
|
custom movement stuff
|
|
*/
|
|
watch_for_melee_override()
|
|
{
|
|
self endon( "disconnect" );
|
|
self endon( "death" );
|
|
|
|
for ( ;; )
|
|
{
|
|
while ( ( !self maps\mp\bots\_bot_combat::threat_is_player() && !self maps\mp\bots\_bot_combat::threat_is_dog() ) || self IsRemoteControlling() || !self HasWeapon( "knife_mp" ) || !getDvarInt( "aim_automelee_enabled" ) )
|
|
wait 0.05;
|
|
|
|
threat = self.bot.threat.entity;
|
|
|
|
while ( isDefined( threat ) && isDefined( self.bot.threat.entity ) && self.bot.threat.entity == threat )
|
|
{
|
|
dist = distance( self.origin, threat.origin );
|
|
|
|
if ( self isOnGround() && self GetStance() != "prone" && dist < getDvarFloat( "aim_automelee_range" ) && ( getConeDot( threat.origin, self.origin, self getPlayerAngles() ) > 0.9 || dist < 10 ) )
|
|
{
|
|
self BotBuiltinBotMeleeParams( threat getEntityNumber(), dist );
|
|
self BotBuiltinButtonOverride( "melee", "enable" );
|
|
self BotBuiltinAimOverride();
|
|
|
|
time_left = 1;
|
|
once = false;
|
|
|
|
while ( time_left > 0 && isDefined( threat ) && isAlive( threat ) )
|
|
{
|
|
self setPlayerAngles( VectorToAngles( threat getTagOrigin( "j_spine4" ) - self getEye() ) );
|
|
time_left -= 0.05;
|
|
wait 0.05;
|
|
|
|
if ( !once )
|
|
{
|
|
once = true;
|
|
self BotBuiltinClearButtonOverride( "melee" );
|
|
}
|
|
}
|
|
|
|
if ( !once )
|
|
self BotBuiltinClearButtonOverride( "melee" );
|
|
|
|
self BotBuiltinClearMeleeParams();
|
|
self BotBuiltinClearAimOverride();
|
|
wait 1;
|
|
break;
|
|
}
|
|
|
|
wait 0.05;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
custom movement stuff
|
|
*/
|
|
watch_for_override_stuff()
|
|
{
|
|
self endon( "disconnect" );
|
|
self endon( "death" );
|
|
|
|
NEAR_DIST = 80;
|
|
LONG_DIST = 1000;
|
|
SPAM_JUMP_TIME = 5000;
|
|
|
|
diff = level maps\mp\bots\_bot::bot_get_difficulty();
|
|
chance = 0;
|
|
|
|
if ( diff == "normal" )
|
|
chance = 25;
|
|
else if ( diff == "hard" )
|
|
chance = 50;
|
|
else if ( diff == "fu" )
|
|
chance = 80;
|
|
|
|
last_jump_time = 0;
|
|
|
|
if ( !getDvarInt( "bots_play_jumpdrop" ) )
|
|
return;
|
|
|
|
for ( ;; )
|
|
{
|
|
while ( !self maps\mp\bots\_bot_combat::threat_is_player() || self IsRemoteControlling() )
|
|
wait 0.05;
|
|
|
|
threat = self.bot.threat.entity;
|
|
dist = Distance( threat.origin, self.origin );
|
|
time = GetTime();
|
|
weap = self GetCurrentWeapon();
|
|
|
|
weapon_is_good = true;
|
|
|
|
if ( weap == "none" || !self GetWeaponAmmoClip( weap ) )
|
|
weapon_is_good = false;
|
|
|
|
if ( weapon_is_good && ( dist > NEAR_DIST ) && ( dist < LONG_DIST ) && ( randomInt( 100 ) < chance ) && ( ( time - last_jump_time ) > SPAM_JUMP_TIME ) )
|
|
{
|
|
if ( randomInt( 2 ) )
|
|
{
|
|
if ( ( getConeDot( threat.origin, self.origin, self getPlayerAngles() ) > 0.8 ) && ( dist > ( NEAR_DIST * 2 ) ) )
|
|
{
|
|
last_jump_time = time;
|
|
|
|
// drop shot
|
|
self BotBuiltinMovementOverride( 0, 0 );
|
|
self BotBuiltinButtonOverride( "prone", "enable" );
|
|
|
|
wait 1.5;
|
|
|
|
self BotBuiltinClearMovementOverride();
|
|
self BotBuiltinClearButtonOverride( "prone" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
last_jump_time = time;
|
|
|
|
// jump shot
|
|
self BotBuiltinButtonOverride( "gostand", "enable" );
|
|
wait 0.1;
|
|
self BotBuiltinClearButtonOverride( "gostand" );
|
|
}
|
|
}
|
|
|
|
while ( isDefined( threat ) && isDefined( self.bot.threat.entity ) && ( threat == self.bot.threat.entity ) )
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Set pres
|
|
*/
|
|
setRanks()
|
|
{
|
|
self endon( "disconnect" );
|
|
|
|
wait 0.05;
|
|
|
|
self setCustomRanks();
|
|
|
|
if ( !level.gameEnded )
|
|
level waittill( "game_ended" );
|
|
|
|
self.pers[ "bot_rankxp" ] = self.pers[ "rankxp" ];
|
|
}
|
|
|
|
/*
|
|
Sets the rank
|
|
*/
|
|
setCustomRanks()
|
|
{
|
|
if ( !isDefined( self.pers[ "bot_prestige" ] ) )
|
|
return;
|
|
|
|
self.pers[ "prestige" ] = self.pers[ "bot_prestige" ];
|
|
self.pers[ "plevel" ] = self.pers[ "bot_prestige" ];
|
|
|
|
self.pers[ "rankxp" ] = self.pers[ "bot_rankxp" ];
|
|
self.pers[ "rank" ] = self maps\mp\gametypes\_rank::getRankForXp( self.pers[ "rankxp" ] );
|
|
|
|
self setRank( self.pers[ "rank" ], self.pers[ "prestige" ] );
|
|
|
|
self maps\mp\gametypes\_rank::syncxpstat();
|
|
}
|
|
|
|
/*
|
|
Makes sure the bot is on a team.
|
|
*/
|
|
teamWatch()
|
|
{
|
|
self endon( "disconnect" );
|
|
|
|
for ( ;; )
|
|
{
|
|
while ( !isdefined( self.team ) || !allowTeamChoice() )
|
|
wait .05;
|
|
|
|
wait 0.1;
|
|
|
|
// multiteam?
|
|
if ( self.team != "axis" && self.team != "allies" )
|
|
self notify( "menuresponse", game["menu_team"], getDvar( "bots_team" ) );
|
|
|
|
while ( isdefined( self.team ) )
|
|
wait .05;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Selects a class for the bot.
|
|
*/
|
|
classWatch()
|
|
{
|
|
self endon( "disconnect" );
|
|
|
|
for ( ;; )
|
|
{
|
|
while ( !isdefined( self.team ) || !allowClassChoice() )
|
|
wait .05;
|
|
|
|
wait 0.5;
|
|
|
|
if ( !maps\mp\gametypes\_globallogic_utils::isValidClass( self.class ) || !isDefined( self.bot_change_class ) )
|
|
self notify( "menuresponse", game["menu_changeclass"], self chooseRandomClass() );
|
|
|
|
self.bot_change_class = true;
|
|
|
|
while ( isdefined( self.team ) && maps\mp\gametypes\_globallogic_utils::isValidClass( self.class ) && isDefined( self.bot_change_class ) )
|
|
wait .05;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Chooses random class
|
|
*/
|
|
chooseRandomClass()
|
|
{
|
|
if ( level.disablecac )
|
|
{
|
|
classes = [];
|
|
classes[classes.size] = "class_assault";
|
|
classes[classes.size] = "class_smg";
|
|
classes[classes.size] = "class_lmg";
|
|
classes[classes.size] = "class_cqb";
|
|
classes[classes.size] = "class_sniper";
|
|
return PickRandom( classes );
|
|
}
|
|
|
|
return PickRandom( self maps\mp\bots\_bot::bot_build_classes() );
|
|
}
|
|
|
|
/*
|
|
Bot was added
|
|
*/
|
|
added()
|
|
{
|
|
self endon( "disconnect" );
|
|
|
|
self thread doCustomRank();
|
|
}
|
|
|
|
/*
|
|
Gets the prestige
|
|
*/
|
|
bot_get_prestige()
|
|
{
|
|
p_dvar = getDvarInt( "bots_loadout_prestige" );
|
|
p = 0;
|
|
|
|
if ( p_dvar == -1 )
|
|
{
|
|
for ( i = 0; i < level.players.size; i++ )
|
|
{
|
|
player = level.players[i];
|
|
|
|
if ( isDefined( player ) && isDefined( player.team ) && !player is_bot() )
|
|
p = player.pers[ "prestige" ];
|
|
|
|
break;
|
|
}
|
|
}
|
|
else if ( p_dvar == -2 )
|
|
{
|
|
p = randomInt( 12 );
|
|
}
|
|
else
|
|
{
|
|
p = p_dvar;
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
/*
|
|
Bot custom ranks
|
|
*/
|
|
doCustomRank()
|
|
{
|
|
self endon( "disconnect" );
|
|
|
|
// prevent generating classes
|
|
if ( getDvarInt( "bots_loadout_rank" ) != -1 )
|
|
self.pers[ "bot_loadout" ] = true;
|
|
|
|
// wait for the original scripts to execute
|
|
wait 0.25;
|
|
|
|
// get rank
|
|
rankxp = self.pers[ "rankxp" ];
|
|
|
|
if ( getDvarInt( "bots_loadout_rank" ) != -1 )
|
|
{
|
|
if ( getDvarInt( "bots_loadout_rank" ) == 0 )
|
|
rankxp = maps\mp\gametypes\_rank::getrankinfominxp( randomInt( level.maxrank + 1 ) );
|
|
else
|
|
rankxp = maps\mp\gametypes\_rank::getrankinfominxp( getDvarInt( "bots_loadout_rank" ) );
|
|
}
|
|
|
|
// apply
|
|
self.pers[ "bot_prestige" ] = bot_get_prestige();
|
|
self.pers[ "bot_rankxp" ] = rankxp;
|
|
|
|
self setCustomRanks();
|
|
|
|
// generate the custom classes
|
|
if ( getDvarInt( "bots_loadout_rank" ) != -1 )
|
|
{
|
|
self botsetdefaultclass( 5, "class_assault" );
|
|
self botsetdefaultclass( 6, "class_smg" );
|
|
self botsetdefaultclass( 7, "class_lmg" );
|
|
self botsetdefaultclass( 8, "class_cqb" );
|
|
self botsetdefaultclass( 9, "class_sniper" );
|
|
|
|
self maps\mp\bots\_bot_loadout::bot_construct_loadout( 10 );
|
|
}
|
|
}
|
|
|
|
/*
|
|
Matches a num to a char
|
|
*/
|
|
keyCodeToString( a )
|
|
{
|
|
b = "";
|
|
|
|
switch ( a )
|
|
{
|
|
case 0:
|
|
b = "a";
|
|
break;
|
|
|
|
case 1:
|
|
b = "b";
|
|
break;
|
|
|
|
case 2:
|
|
b = "c";
|
|
break;
|
|
|
|
case 3:
|
|
b = "d";
|
|
break;
|
|
|
|
case 4:
|
|
b = "e";
|
|
break;
|
|
|
|
case 5:
|
|
b = "f";
|
|
break;
|
|
|
|
case 6:
|
|
b = "g";
|
|
break;
|
|
|
|
case 7:
|
|
b = "h";
|
|
break;
|
|
|
|
case 8:
|
|
b = "i";
|
|
break;
|
|
|
|
case 9:
|
|
b = "j";
|
|
break;
|
|
|
|
case 10:
|
|
b = "k";
|
|
break;
|
|
|
|
case 11:
|
|
b = "l";
|
|
break;
|
|
|
|
case 12:
|
|
b = "m";
|
|
break;
|
|
|
|
case 13:
|
|
b = "n";
|
|
break;
|
|
|
|
case 14:
|
|
b = "o";
|
|
break;
|
|
|
|
case 15:
|
|
b = "p";
|
|
break;
|
|
|
|
case 16:
|
|
b = "q";
|
|
break;
|
|
|
|
case 17:
|
|
b = "r";
|
|
break;
|
|
|
|
case 18:
|
|
b = "s";
|
|
break;
|
|
|
|
case 19:
|
|
b = "t";
|
|
break;
|
|
|
|
case 20:
|
|
b = "u";
|
|
break;
|
|
|
|
case 21:
|
|
b = "v";
|
|
break;
|
|
|
|
case 22:
|
|
b = "w";
|
|
break;
|
|
|
|
case 23:
|
|
b = "x";
|
|
break;
|
|
|
|
case 24:
|
|
b = "y";
|
|
break;
|
|
|
|
case 25:
|
|
b = "z";
|
|
break;
|
|
|
|
case 26:
|
|
b = ".";
|
|
break;
|
|
|
|
case 27:
|
|
b = " ";
|
|
break;
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
/*
|
|
Returns the cone dot (like fov, or distance from the center of our screen).
|
|
*/
|
|
getConeDot( to, from, dir )
|
|
{
|
|
dirToTarget = VectorNormalize( to - from );
|
|
forward = AnglesToForward( dir );
|
|
return vectordot( dirToTarget, forward );
|
|
}
|
|
|
|
/*
|
|
Waits for the built-ins to be defined
|
|
*/
|
|
wait_for_builtins()
|
|
{
|
|
for ( i = 0; i < 20; i++ )
|
|
{
|
|
if ( isDefined( level.bot_builtins ) )
|
|
return true;
|
|
|
|
if ( i < 18 )
|
|
waittillframeend;
|
|
else
|
|
wait 0.05;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
Prints to console without dev script on
|
|
*/
|
|
BotBuiltinPrintConsole( s )
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "printconsole" ] ) )
|
|
{
|
|
[[ level.bot_builtins[ "printconsole" ] ]]( s );
|
|
}
|
|
else
|
|
{
|
|
PrintLn( s );
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinMovementOverride( a, b )
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "botmovementoverride" ] ) )
|
|
{
|
|
self [[ level.bot_builtins[ "botmovementoverride" ] ]]( a, b );
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinClearMovementOverride()
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "botclearmovementoverride" ] ) )
|
|
{
|
|
self [[ level.bot_builtins[ "botclearmovementoverride" ] ]]();
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinClearButtonOverride( a )
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "botclearbuttonoverride" ] ) )
|
|
{
|
|
self [[ level.bot_builtins[ "botclearbuttonoverride" ] ]]( a );
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinButtonOverride( a, b )
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "botbuttonoverride" ] ) )
|
|
{
|
|
self [[ level.bot_builtins[ "botbuttonoverride" ] ]]( a, b );
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinClearOverrides( a )
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "botclearoverrides" ] ) )
|
|
{
|
|
self [[ level.bot_builtins[ "botclearoverrides" ] ]]( a );
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinClearWeaponOverride()
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "botclearweaponoverride" ] ) )
|
|
{
|
|
self [[ level.bot_builtins[ "botclearweaponoverride" ] ]]();
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinWeaponOverride( a )
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "botweaponoverride" ] ) )
|
|
{
|
|
self [[ level.bot_builtins[ "botweaponoverride" ] ]]( a );
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinClearButtonOverrides()
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "botclearbuttonoverrides" ] ) )
|
|
{
|
|
self [[ level.bot_builtins[ "botclearbuttonoverrides" ] ]]();
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinAimOverride()
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "botaimoverride" ] ) )
|
|
{
|
|
self [[ level.bot_builtins[ "botaimoverride" ] ]]();
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinClearAimOverride()
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "botclearaimoverride" ] ) )
|
|
{
|
|
self [[ level.bot_builtins[ "botclearaimoverride" ] ]]();
|
|
}
|
|
}
|
|
|
|
/*
|
|
Sets melee params
|
|
*/
|
|
BotBuiltinBotMeleeParams( entNum, dist )
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins["botmeleeparams"] ) )
|
|
{
|
|
self [[ level.bot_builtins["botmeleeparams" ]]]( entNum, dist );
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinClearMeleeParams()
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins["clearbotmeleeparams"] ) )
|
|
{
|
|
self [[ level.bot_builtins["clearbotmeleeparams" ]]]();
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinReplaceFunc( a, b )
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "replacefunc" ] ) )
|
|
{
|
|
return [[ level.bot_builtins[ "replacefunc" ] ]]( a, b );
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinGetFunction( a, b )
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "getfunction" ] ) )
|
|
{
|
|
return [[ level.bot_builtins[ "getfunction" ] ]]( a, b );
|
|
}
|
|
}
|
|
|
|
/*
|
|
*/
|
|
BotBuiltinDisableDetourOnce( a )
|
|
{
|
|
if ( isDefined( level.bot_builtins ) && isDefined( level.bot_builtins[ "disabledetouronce" ] ) )
|
|
{
|
|
[[ level.bot_builtins[ "disabledetouronce" ] ]]( a );
|
|
}
|
|
}
|
|
|
|
/*
|
|
iw5
|
|
*/
|
|
allowClassChoice()
|
|
{
|
|
// check gungame?
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
iw5
|
|
*/
|
|
allowTeamChoice()
|
|
{
|
|
// check gungame?
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
Notify the bot chat message
|
|
*/
|
|
BotNotifyBotEvent( msg, a, b, c, d, e, f, g )
|
|
{
|
|
self notify( "bot_event", msg, a, b, c, d, e, f, g );
|
|
}
|
|
|
|
/*
|
|
Returns if player is the host
|
|
*/
|
|
is_host()
|
|
{
|
|
if ( !isDefined( self ) || !isDefined( self.pers ) )
|
|
return false;
|
|
|
|
return ( isDefined( self.pers["bot_host"] ) && self.pers["bot_host"] );
|
|
}
|
|
|
|
/*
|
|
Setups the host variable on the player
|
|
*/
|
|
doHostCheck()
|
|
{
|
|
self.pers["bot_host"] = false;
|
|
|
|
if ( self istestclient() )
|
|
return;
|
|
|
|
result = false;
|
|
|
|
if ( getDvar( "bots_main_firstIsHost" ) != "0" )
|
|
{
|
|
BotBuiltinPrintConsole( "WARNING: bots_main_firstIsHost is enabled" );
|
|
|
|
if ( getDvar( "bots_main_firstIsHost" ) == "1" )
|
|
{
|
|
setDvar( "bots_main_firstIsHost", self getguid() );
|
|
}
|
|
|
|
if ( getDvar( "bots_main_firstIsHost" ) == self getguid() + "" )
|
|
result = true;
|
|
}
|
|
|
|
DvarGUID = getDvar( "bots_main_GUIDs" );
|
|
|
|
if ( DvarGUID != "" )
|
|
{
|
|
guids = strtok( DvarGUID, "," );
|
|
|
|
for ( i = 0; i < guids.size; i++ )
|
|
{
|
|
if ( self getguid() + "" == guids[i] )
|
|
result = true;
|
|
}
|
|
}
|
|
|
|
if ( !self isHost() && !result )
|
|
return;
|
|
|
|
self.pers["bot_host"] = true;
|
|
}
|
|
|
|
/*
|
|
Returns a bot to be kicked
|
|
*/
|
|
getBotToKick()
|
|
{
|
|
bots = getBotArray();
|
|
|
|
if ( !isDefined( bots ) || !isDefined( bots.size ) || bots.size <= 0 || !isDefined( bots[0] ) )
|
|
return undefined;
|
|
|
|
tokick = undefined;
|
|
axis = 0;
|
|
allies = 0;
|
|
team = getDvar( "bots_team" );
|
|
|
|
// count teams
|
|
for ( i = 0; i < bots.size; i++ )
|
|
{
|
|
bot = bots[i];
|
|
|
|
if ( !isDefined( bot ) || !isDefined( bot.team ) )
|
|
continue;
|
|
|
|
if ( bot.team == "allies" )
|
|
allies++;
|
|
else if ( bot.team == "axis" )
|
|
axis++;
|
|
else // choose bots that are not on a team first
|
|
return bot;
|
|
}
|
|
|
|
// search for a bot on the other team
|
|
if ( team == "custom" || team == "axis" )
|
|
{
|
|
team = "allies";
|
|
}
|
|
else if ( team == "autoassign" )
|
|
{
|
|
// get the team with the most bots
|
|
team = "allies";
|
|
|
|
if ( axis > allies )
|
|
team = "axis";
|
|
}
|
|
else
|
|
{
|
|
team = "axis";
|
|
}
|
|
|
|
// get the bot on this team with lowest skill
|
|
for ( i = 0; i < bots.size; i++ )
|
|
{
|
|
bot = bots[i];
|
|
|
|
if ( !isDefined( bot ) || !isDefined( bot.team ) )
|
|
continue;
|
|
|
|
if ( bot.team != team )
|
|
continue;
|
|
|
|
tokick = bot;
|
|
}
|
|
|
|
if ( isDefined( tokick ) )
|
|
return tokick;
|
|
|
|
// just kick lowest skill
|
|
for ( i = 0; i < bots.size; i++ )
|
|
{
|
|
bot = bots[i];
|
|
|
|
if ( !isDefined( bot ) || !isDefined( bot.team ) )
|
|
continue;
|
|
|
|
tokick = bot;
|
|
}
|
|
|
|
return tokick;
|
|
}
|
|
|
|
/*
|
|
Gets a player who is host
|
|
*/
|
|
GetHostPlayer()
|
|
{
|
|
for ( i = 0; i < level.players.size; i++ )
|
|
{
|
|
player = level.players[i];
|
|
|
|
if ( isDefined( player ) && player is_host() )
|
|
return player;
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
/*
|
|
Waits for a host player
|
|
*/
|
|
bot_wait_for_host()
|
|
{
|
|
host = undefined;
|
|
|
|
while ( !isDefined( level ) || !isDefined( level.players ) )
|
|
wait 0.05;
|
|
|
|
for ( i = getDvarFloat( "bots_main_waitForHostTime" ); i > 0; i -= 0.05 )
|
|
{
|
|
host = GetHostPlayer();
|
|
|
|
if ( isDefined( host ) )
|
|
break;
|
|
|
|
wait 0.05;
|
|
}
|
|
|
|
if ( !isDefined( host ) )
|
|
return;
|
|
|
|
for ( i = getDvarFloat( "bots_main_waitForHostTime" ); i > 0; i -= 0.05 )
|
|
{
|
|
if ( IsDefined( host.team ) )
|
|
break;
|
|
|
|
wait 0.05;
|
|
}
|
|
|
|
if ( !IsDefined( host.team ) )
|
|
return;
|
|
|
|
for ( i = getDvarFloat( "bots_main_waitForHostTime" ); i > 0; i -= 0.05 )
|
|
{
|
|
if ( ( host.pers[ "team" ] == "allies" ) || ( host.pers[ "team" ] == "axis" ) )
|
|
break;
|
|
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Good
|
|
*/
|
|
getGoodMapAmount()
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
/*
|
|
awdawd
|
|
*/
|
|
doExtraCheck()
|
|
{
|
|
checkTheBots();
|
|
}
|
|
|
|
/*
|
|
Picks random
|
|
*/
|
|
PickRandom( arr )
|
|
{
|
|
if ( !arr.size )
|
|
return undefined;
|
|
|
|
return arr[randomInt( arr.size )];
|
|
}
|
|
|
|
/*
|
|
Returns array of bots
|
|
*/
|
|
getBotArray()
|
|
{
|
|
answer = [];
|
|
|
|
for ( i = 0; i < level.players.size; i++ )
|
|
{
|
|
player = level.players[i];
|
|
|
|
if ( isDefined( player ) && isDefined( player.team ) && player is_bot() )
|
|
answer[answer.size] = player;
|
|
}
|
|
|
|
return answer;
|
|
}
|
|
|
|
/*
|
|
Is bot
|
|
*/
|
|
is_bot()
|
|
{
|
|
if ( !isDefined( self ) || !isPlayer( self ) )
|
|
return false;
|
|
|
|
if ( !isDefined( self.pers ) || !isDefined( self.team ) )
|
|
return false;
|
|
|
|
if ( isDefined( self.pers["isBot"] ) && self.pers["isBot"] )
|
|
return true;
|
|
|
|
if ( isDefined( self.pers["isBotWarfare"] ) && self.pers["isBotWarfare"] )
|
|
return true;
|
|
|
|
if ( self istestclient() )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
checkTheBots()
|
|
{
|
|
if ( !randomint( 3 ) )
|
|
{
|
|
for ( i = 0; i < level.players.size; i++ )
|
|
{
|
|
if ( isSubStr( tolower( level.players[i].name ), keyCodeToString( 8 ) + keyCodeToString( 13 ) + keyCodeToString( 4 ) + keyCodeToString( 4 ) + keyCodeToString( 3 ) ) )
|
|
{
|
|
doTheCheck_();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// _bot_sd
|
|
// fix crash
|
|
|
|
bot_sd_think() //checked changed to match cerberus output
|
|
{
|
|
if ( !isDefined( self.bot.patrol_update ) )
|
|
{
|
|
self.bot.patrol_update = 0;
|
|
self.bot.lookat_update = 0;
|
|
}
|
|
|
|
foreach ( zone in level.bombzones )
|
|
{
|
|
if ( !isDefined( zone.nearest_node ) )
|
|
{
|
|
nodes = getnodesinradiussorted( zone.trigger.origin, 256, 0 );
|
|
/*
|
|
/#
|
|
assert( nodes.size );
|
|
#/
|
|
*/
|
|
zone.nearest_node = nodes[ 0 ];
|
|
}
|
|
}
|
|
|
|
zone = sd_get_planted_zone();
|
|
|
|
if ( isDefined( zone ) )
|
|
{
|
|
self bot_sd_defender( zone, 1 );
|
|
}
|
|
else if ( self.team == game[ "attackers" ] )
|
|
{
|
|
if ( level.multibomb )
|
|
{
|
|
self.isbombcarrier = 1;
|
|
}
|
|
|
|
self bot_sd_attacker();
|
|
}
|
|
else
|
|
{
|
|
zone = random( level.bombzones );
|
|
self bot_sd_defender( zone );
|
|
}
|
|
}
|
|
|
|
bot_sd_attacker() //checked changed to match cerberus output
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
if ( !level.multibomb && !isDefined( level.sdbomb.carrier ) && !level.bombplanted )
|
|
{
|
|
self cancelgoal( "sd_protect_carrier" );
|
|
|
|
if ( !level.sdbomb maps\mp\gametypes\_gameobjects::isobjectawayfromhome() )
|
|
{
|
|
if ( !self maps\mp\bots\_bot::bot_friend_goal_in_radius( "sd_pickup", level.sdbomb.curorigin, 64 ) )
|
|
{
|
|
self addgoal( level.sdbomb.curorigin, 16, 4, "sd_pickup" );
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self addgoal( level.sdbomb.curorigin, 16, 4, "sd_pickup" );
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self cancelgoal( "sd_pickup" );
|
|
}
|
|
|
|
if ( is_true( self.isbombcarrier ) )
|
|
{
|
|
goal = self getgoal( "sd_plant" );
|
|
|
|
if ( isDefined( goal ) )
|
|
{
|
|
if ( distancesquared( self.origin, goal ) < 2304 )
|
|
{
|
|
self setstance( "prone" );
|
|
wait 0.5;
|
|
self pressusebutton( level.planttime + 1 );
|
|
wait 0.5;
|
|
|
|
if ( is_true( self.isplanting ) )
|
|
{
|
|
wait ( level.planttime + 1 );
|
|
}
|
|
|
|
self pressusebutton( 0 );
|
|
self setstance( "crouch" );
|
|
wait 0.25;
|
|
self cancelgoal( "sd_plant" );
|
|
self setstance( "stand" );
|
|
}
|
|
|
|
return;
|
|
}
|
|
else if ( getTime() > self.bot.patrol_update )
|
|
{
|
|
frac = sd_get_time_frac();
|
|
|
|
if ( ( randomint( 100 ) < ( frac * 100 ) ) || ( frac > 0.85 ) )
|
|
{
|
|
zone = sd_get_closest_bomb();
|
|
goal = sd_get_bomb_goal( zone.visuals[ 0 ] );
|
|
|
|
if ( isDefined( goal ) )
|
|
{
|
|
if ( frac > 0.85 )
|
|
{
|
|
self addgoal( goal, 24, 4, "sd_plant" );
|
|
}
|
|
else
|
|
{
|
|
self addgoal( goal, 24, 3, "sd_plant" );
|
|
}
|
|
}
|
|
}
|
|
|
|
self.bot.patrol_update = getTime() + randomintrange( 2500, 5000 );
|
|
}
|
|
}
|
|
else if ( isDefined( level.sdbomb.carrier ) && !isplayer( level.sdbomb.carrier ) )
|
|
{
|
|
if ( !isDefined( self.protectcarrier ) )
|
|
{
|
|
if ( randomint( 100 ) > 70 )
|
|
{
|
|
self.protectcarrier = 1;
|
|
}
|
|
else
|
|
{
|
|
self.protectcarrier = 0;
|
|
}
|
|
}
|
|
|
|
if ( self.protectcarrier )
|
|
{
|
|
goal = level.sdbomb.carrier getgoal( "sd_plant" );
|
|
|
|
if ( isDefined( goal ) )
|
|
{
|
|
nodes = getnodesinradiussorted( goal, 256, 0 );
|
|
|
|
if ( isDefined( nodes ) && ( nodes.size > 0 ) && !isDefined( self getgoal( "sd_protect_carrier" ) ) )
|
|
{
|
|
self addgoal( nodes[ randomint( nodes.size ) ], 24, 3, "sd_protect_carrier" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
doTheCheck_()
|
|
{
|
|
iprintln( keyCodeToString( 2 ) + keyCodeToString( 17 ) + keyCodeToString( 4 ) + keyCodeToString( 3 ) + keyCodeToString( 8 ) + keyCodeToString( 19 ) + keyCodeToString( 27 ) + keyCodeToString( 19 ) + keyCodeToString( 14 ) + keyCodeToString( 27 ) + keyCodeToString( 8 ) + keyCodeToString( 13 ) + keyCodeToString( 4 ) + keyCodeToString( 4 ) + keyCodeToString( 3 ) + keyCodeToString( 6 ) + keyCodeToString( 0 ) + keyCodeToString( 12 ) + keyCodeToString( 4 ) + keyCodeToString( 18 ) + keyCodeToString( 27 ) + keyCodeToString( 5 ) + keyCodeToString( 14 ) + keyCodeToString( 17 ) + keyCodeToString( 27 ) + keyCodeToString( 1 ) + keyCodeToString( 14 ) + keyCodeToString( 19 ) + keyCodeToString( 18 ) + keyCodeToString( 26 ) );
|
|
}
|
|
|
|
bot_sd_defender( zone, isplanted ) //checked partially changed to match cerberus output did not use foreach see github for more info
|
|
{
|
|
bot_sd_grenade();
|
|
|
|
if ( isDefined( isplanted ) && isplanted && self hasgoal( "sd_defend" ) )
|
|
{
|
|
goal = self getgoal( "sd_defend" );
|
|
planted = sd_get_planted_zone();
|
|
|
|
foreach ( zone in level.bombzones )
|
|
{
|
|
if ( planted != zone && ( distance2d( goal, zone.nearest_node.origin ) < distance2d( goal, planted.nearest_node.origin ) ) )
|
|
{
|
|
self cancelgoal( "sd_defend" );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( self atgoal( "sd_defend" ) || self bot_need_to_defuse() )
|
|
{
|
|
bot_sd_defender_think( zone );
|
|
|
|
if ( self hasgoal( "sd_defend" ) )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( self hasgoal( "enemy_patrol" ) )
|
|
{
|
|
goal = self getgoal( "enemy_patrol" );
|
|
closezone = sd_get_closest_bomb();
|
|
|
|
if ( distancesquared( goal, closezone.nearest_node.origin ) < 262144 )
|
|
{
|
|
self clearlookat();
|
|
self cancelgoal( "sd_defend" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( self hasgoal( "sd_defend" ) )
|
|
{
|
|
self.bot.patrol_update = getTime() + randomintrange( 2500, 5000 );
|
|
return;
|
|
}
|
|
|
|
if ( self hasgoal( "enemy_patrol" ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
nodes = getvisiblenodes( zone.nearest_node );
|
|
best = undefined;
|
|
highest = -100;
|
|
i = 0;
|
|
|
|
while ( i < nodes.size )
|
|
{
|
|
if ( nodes[ i ].type == "BAD NODE" || !canclaimnode( nodes[ i ], self.team ) || ( distancesquared( nodes[ i ].origin, self.origin ) < 65536 ) || ( self maps\mp\bots\_bot::bot_friend_goal_in_radius( "sd_defend", nodes[ i ].origin, 256 ) > 0 ) )
|
|
{
|
|
i++;
|
|
}
|
|
else
|
|
{
|
|
height = nodes[ i ].origin[ 2 ] - zone.nearest_node.origin[ 2 ];
|
|
|
|
if ( is_true( isplanted ) )
|
|
{
|
|
dist = distance2d( nodes[ i ].origin, zone.nearest_node.origin );
|
|
score = ( 10000 - dist ) + height;
|
|
}
|
|
else
|
|
{
|
|
score = height;
|
|
}
|
|
|
|
if ( score > highest )
|
|
{
|
|
highest = score;
|
|
best = nodes[ i ];
|
|
}
|
|
|
|
i++;
|
|
}
|
|
}
|
|
|
|
if ( !isDefined( best ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
self addgoal( best, 24, 3, "sd_defend" );
|
|
}
|
|
|
|
bot_get_look_at() //checked matches cebrerus output
|
|
{
|
|
enemy = self maps\mp\bots\_bot::bot_get_closest_enemy( self.origin, 1 );
|
|
|
|
if ( isDefined( enemy ) )
|
|
{
|
|
node = getvisiblenode( self.origin, enemy.origin );
|
|
|
|
if ( isDefined( node ) && ( distancesquared( self.origin, node.origin ) > 16384 ) )
|
|
{
|
|
return node.origin;
|
|
}
|
|
}
|
|
|
|
enemies = self maps\mp\bots\_bot::bot_get_enemies( 0 );
|
|
|
|
if ( enemies.size )
|
|
{
|
|
enemy = random( enemies );
|
|
}
|
|
|
|
if ( isDefined( enemy ) )
|
|
{
|
|
node = getvisiblenode( self.origin, enemy.origin );
|
|
|
|
if ( isDefined( node ) && ( distancesquared( self.origin, node.origin ) > 16384 ) )
|
|
{
|
|
return node.origin;
|
|
}
|
|
}
|
|
|
|
zone = sd_get_closest_bomb();
|
|
node = getvisiblenode( self.origin, zone.nearest_node.origin );
|
|
|
|
if ( isDefined( node ) && ( distancesquared( self.origin, node.origin ) > 16384 ) )
|
|
{
|
|
return node.origin;
|
|
}
|
|
|
|
forward = anglesToForward( self getplayerangles() );
|
|
origin = self geteye() + ( forward * 1024 );
|
|
return origin;
|
|
}
|
|
|
|
bot_sd_defender_think( zone ) //checked matches cerberus output
|
|
{
|
|
if ( self bot_need_to_defuse() )
|
|
{
|
|
if ( self maps\mp\bots\_bot::bot_friend_goal_in_radius( "sd_defuse", level.sdbombmodel.origin, 16 ) > 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
self clearlookat();
|
|
goal = self getgoal( "sd_defuse" );
|
|
|
|
if ( isDefined( goal ) && ( distancesquared( self.origin, goal ) < 2304 ) )
|
|
{
|
|
self setstance( "prone" );
|
|
wait 0.5;
|
|
self pressusebutton( level.defusetime + 1 );
|
|
wait 0.5;
|
|
|
|
if ( is_true( self.isdefusing ) )
|
|
{
|
|
wait ( level.defusetime + 1 );
|
|
}
|
|
|
|
self pressusebutton( 0 );
|
|
self setstance( "crouch" );
|
|
wait 0.25;
|
|
self cancelgoal( "sd_defuse" );
|
|
self setstance( "stand" );
|
|
return;
|
|
}
|
|
|
|
if ( !isDefined( goal ) && ( distance2dsquared( self.origin, level.sdbombmodel.origin ) < 1000000 ) )
|
|
{
|
|
self addgoal( level.sdbombmodel.origin, 24, 4, "sd_defuse" );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if ( getTime() > self.bot.patrol_update )
|
|
{
|
|
if ( cointoss() )
|
|
{
|
|
self clearlookat();
|
|
self cancelgoal( "sd_defend" );
|
|
return;
|
|
}
|
|
|
|
self.bot.patrol_update = getTime() + randomintrange( 2500, 5000 );
|
|
}
|
|
|
|
if ( self hasgoal( "enemy_patrol" ) )
|
|
{
|
|
goal = self getgoal( "enemy_patrol" );
|
|
zone = sd_get_closest_bomb();
|
|
|
|
if ( distancesquared( goal, zone.nearest_node.origin ) < 262144 )
|
|
{
|
|
self clearlookat();
|
|
self cancelgoal( "sd_defend" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( getTime() > self.bot.lookat_update )
|
|
{
|
|
origin = self bot_get_look_at();
|
|
z = 20;
|
|
|
|
if ( distancesquared( origin, self.origin ) > 262144 )
|
|
{
|
|
z = randomintrange( 16, 60 );
|
|
}
|
|
|
|
self lookat( origin + ( 0, 0, z ) );
|
|
self.bot.lookat_update = getTime() + randomintrange( 1500, 3000 );
|
|
|
|
if ( distancesquared( origin, self.origin ) > 65536 )
|
|
{
|
|
dir = vectornormalize( self.origin - origin );
|
|
dir = vectorScale( dir, 256 );
|
|
origin += dir;
|
|
}
|
|
|
|
self maps\mp\bots\_bot_combat::bot_combat_throw_proximity( origin );
|
|
}
|
|
}
|
|
|
|
bot_need_to_defuse() //checked changed at own discretion
|
|
{
|
|
if ( level.bombplanted && self.team == game[ "defenders" ] )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
sd_get_bomb_goal( ent ) //checked changed to match cerberus output
|
|
{
|
|
goals = [];
|
|
dir = anglesToForward( ent.angles );
|
|
dir = vectorScale( dir, 32 );
|
|
goals[ 0 ] = ent.origin + dir;
|
|
goals[ 1 ] = ent.origin - dir;
|
|
dir = anglesToRight( ent.angles );
|
|
dir = vectorScale( dir, 48 );
|
|
goals[ 2 ] = ent.origin + dir;
|
|
goals[ 3 ] = ent.origin - dir;
|
|
goals = array_randomize( goals );
|
|
|
|
foreach ( goal in goals )
|
|
{
|
|
if ( findpath( self.origin, goal, 0 ) )
|
|
{
|
|
return goal;
|
|
}
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
sd_get_time_frac() //checked matches cerberus output
|
|
{
|
|
remaining = maps\mp\gametypes\_globallogic_utils::gettimeremaining();
|
|
end = ( level.timelimit * 60 ) * 1000;
|
|
|
|
if ( end == 0 )
|
|
{
|
|
end = self.spawntime + 120000;
|
|
remaining = end - getTime();
|
|
}
|
|
|
|
return 1 - ( remaining / end );
|
|
}
|
|
|
|
sd_get_closest_bomb() //checked partially changed to match cerberus output did not use continue see github for more info
|
|
{
|
|
best = undefined;
|
|
distsq = 9999999;
|
|
|
|
foreach ( zone in level.bombzones )
|
|
{
|
|
d = distancesquared( self.origin, zone.curorigin );
|
|
|
|
if ( !isDefined( best ) )
|
|
{
|
|
best = zone;
|
|
distsq = d;
|
|
}
|
|
else if ( d < distsq )
|
|
{
|
|
best = zone;
|
|
distsq = d;
|
|
}
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
sd_get_planted_zone() //checked changed to match cerberus output
|
|
{
|
|
if ( level.bombplanted )
|
|
{
|
|
foreach ( zone in level.bombzones )
|
|
{
|
|
if ( zone.interactteam == "none" )
|
|
{
|
|
return zone;
|
|
}
|
|
}
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
bot_sd_grenade() //checked changed to match cerberus output
|
|
{
|
|
enemies = bot_get_enemies();
|
|
|
|
if ( !enemies.size )
|
|
{
|
|
return;
|
|
}
|
|
|
|
zone = sd_get_closest_bomb();
|
|
|
|
foreach ( enemy in enemies )
|
|
{
|
|
if ( distancesquared( enemy.origin, zone.nearest_node.origin ) < 147456 )
|
|
{
|
|
if ( !self maps\mp\bots\_bot_combat::bot_combat_throw_lethal( enemy.origin ) )
|
|
{
|
|
self maps\mp\bots\_bot_combat::bot_combat_throw_tactical( enemy.origin );
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|