mirror of
https://github.com/JezuzLizard/Recompilable-gscs-for-BO2-zombies-and-multiplayer.git
synced 2025-06-07 17:37:50 -05:00
completed checking all of the remaining bot scripts
_bot_conf, _bot_ctf, _bot_dem, _bot_dom, _bot_hack, _bot_hq, _bot_koth, _bot_sd have all been checked.
This commit is contained in:
JezuzLizard
parent
04c4467ded
commit
d0b1a4648e
@ -1,7 +1,7 @@
|
||||
#include maps/mp/_utility;
|
||||
#include common_scripts/utility;
|
||||
|
||||
bot_conf_think()
|
||||
bot_conf_think() //checked matches cerberus output
|
||||
{
|
||||
time = getTime();
|
||||
if ( time < self.bot.update_objective )
|
||||
@ -20,65 +20,64 @@ bot_conf_think()
|
||||
conf_get_tag_in_sight();
|
||||
}
|
||||
|
||||
conf_get_tag_in_sight()
|
||||
conf_get_tag_in_sight() //checked partially changed to match cerberus output did not use foreach see github for more info
|
||||
{
|
||||
angles = self getplayerangles();
|
||||
forward = anglesToForward( angles );
|
||||
forward = vectornormalize( forward );
|
||||
closest = 999999;
|
||||
_a41 = level.dogtags;
|
||||
_k41 = getFirstArrayKey( _a41 );
|
||||
while ( isDefined( _k41 ) )
|
||||
tags = level.dogtags;
|
||||
i = 0;
|
||||
while ( i < tags.size )
|
||||
{
|
||||
tag = _a41[ _k41 ];
|
||||
if ( is_true( tag.unreachable ) )
|
||||
if ( is_true( tags[ i ].unreachable ) )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
else distsq = distancesquared( tag.curorigin, self.origin );
|
||||
distsq = distancesquared( tags[ i ].curorigin, self.origin );
|
||||
if ( distsq > closest )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
else delta = tag.curorigin - self.origin;
|
||||
delta = tags[ i ].curorigin - self.origin;
|
||||
delta = vectornormalize( delta );
|
||||
dot = vectordot( forward, delta );
|
||||
if ( dot < self.bot.fov && distsq > 40000 )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if ( dot > self.bot.fov && distsq > 1440000 )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
nearest = getnearestnode( tags[ i ].curorigin );
|
||||
if ( !isDefined( nearest ) )
|
||||
{
|
||||
tags[ i ].unreachable = 1;
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if ( ( tags[ i ].curorigin[ 2 ] - nearest.origin[ 2 ] ) > 18 )
|
||||
{
|
||||
tags[ i ].unreachable = 1;
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if ( !isDefined( tags[ i ].unreachable ) && !findpath( self.origin, tags[ i ].curorigin, tags[ i ], 0, 1 ) )
|
||||
{
|
||||
tags[ i ].unreachable = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( dot > self.bot.fov && distsq > 1440000 )
|
||||
{
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
nearest = getnearestnode( tag.curorigin );
|
||||
if ( !isDefined( nearest ) )
|
||||
{
|
||||
tag.unreachable = 1;
|
||||
break;
|
||||
}
|
||||
else if ( ( tag.curorigin[ 2 ] - nearest.origin[ 2 ] ) > 18 )
|
||||
{
|
||||
tag.unreachable = 1;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( !isDefined( tag.unreachable ) && !findpath( self.origin, tag.curorigin, tag, 0, 1 ) )
|
||||
{
|
||||
tag.unreachable = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
tag.unreachable = 0;
|
||||
}
|
||||
closest = distsq;
|
||||
closetag = tag;
|
||||
}
|
||||
}
|
||||
tags[ i ].unreachable = 0;
|
||||
}
|
||||
_k41 = getNextArrayKey( _a41, _k41 );
|
||||
closest = distsq;
|
||||
closetag = tags[ i ];
|
||||
i++;
|
||||
}
|
||||
if ( isDefined( closetag ) )
|
||||
{
|
||||
@ -86,18 +85,16 @@ conf_get_tag_in_sight()
|
||||
}
|
||||
}
|
||||
|
||||
conf_tag_in_radius( origin, radius )
|
||||
conf_tag_in_radius( origin, radius ) //checked changed to match cerberus output
|
||||
{
|
||||
_a106 = level.dogtags;
|
||||
_k106 = getFirstArrayKey( _a106 );
|
||||
while ( isDefined( _k106 ) )
|
||||
foreach ( tag in level.dogtags )
|
||||
{
|
||||
tag = _a106[ _k106 ];
|
||||
if ( distancesquared( origin, tag.curorigin ) < ( radius * radius ) )
|
||||
if ( distancesquared( origin, tag.curorigin ) < radius * radius )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
_k106 = getNextArrayKey( _a106, _k106 );
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -1,3 +1,4 @@
|
||||
//checked includes match cerberus output
|
||||
#include maps/mp/gametypes/_gameobjects;
|
||||
#include maps/mp/bots/_bot_combat;
|
||||
#include maps/mp/bots/_bot;
|
||||
@ -5,7 +6,7 @@
|
||||
#include common_scripts/utility;
|
||||
#include maps/mp/gametypes/ctf;
|
||||
|
||||
bot_ctf_think()
|
||||
bot_ctf_think() //checked changed to match cerberus output changed at own discretion
|
||||
{
|
||||
time = getTime();
|
||||
if ( time < self.bot.update_objective )
|
||||
@ -22,25 +23,16 @@ bot_ctf_think()
|
||||
node = random( nodes );
|
||||
if ( cointoss() )
|
||||
{
|
||||
self maps/mp/bots/_bot_combat::bot_combat_throw_proximity( node.origin, flag_mine.curorigin );
|
||||
}
|
||||
else
|
||||
{
|
||||
}
|
||||
self maps/mp/bots/_bot_combat::bot_combat_throw_proximity( node.origin, flag_mine.curorigin );
|
||||
if ( cointoss() )
|
||||
{
|
||||
self maps/mp/bots/_bot_combat::bot_combat_toss_frag( node.origin, flag_mine.curorigin );
|
||||
}
|
||||
else
|
||||
{
|
||||
}
|
||||
self maps/mp/bots/_bot_combat::bot_combat_toss_frag( node.origin, flag_mine.curorigin );
|
||||
if ( cointoss() )
|
||||
{
|
||||
self maps/mp/bots/_bot_combat::bot_combat_toss_flash( node.origin, flag_mine.curorigin );
|
||||
}
|
||||
else
|
||||
{
|
||||
}
|
||||
self maps/mp/bots/_bot_combat::bot_combat_toss_flash( node.origin, flag_mine.curorigin );
|
||||
}
|
||||
}
|
||||
if ( bot_should_patrol_flag() )
|
||||
@ -58,27 +50,24 @@ bot_ctf_think()
|
||||
home_mine = flag_mine ctf_flag_get_home();
|
||||
if ( ctf_has_flag( flag_enemy ) && self issprinting() && distancesquared( self.origin, home_mine ) < 36864 )
|
||||
{
|
||||
if ( bot_dot_product( home_mine ) > 0,9 )
|
||||
if ( bot_dot_product( home_mine ) > 0.9 )
|
||||
{
|
||||
self bot_dive_to_prone( "stand" );
|
||||
}
|
||||
}
|
||||
else
|
||||
else if ( !flag_mine ishome() && !isDefined( flag_mine.carrier ) )
|
||||
{
|
||||
if ( !flag_mine ishome() && !isDefined( flag_mine.carrier ) )
|
||||
if ( self issprinting() && distancesquared( self.origin, flag_mine.curorigin ) < 36864 )
|
||||
{
|
||||
if ( self issprinting() && distancesquared( self.origin, flag_mine.curorigin ) < 36864 )
|
||||
if ( bot_dot_product( flag_mine.curorigin ) > 0.9 )
|
||||
{
|
||||
if ( bot_dot_product( flag_mine.curorigin ) > 0,9 )
|
||||
{
|
||||
self bot_dive_to_prone( "stand" );
|
||||
}
|
||||
self bot_dive_to_prone( "stand" );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bot_should_patrol_flag()
|
||||
bot_should_patrol_flag() //checked matches cerberus output
|
||||
{
|
||||
flag_mine = ctf_get_flag( self.team );
|
||||
flag_enemy = ctf_get_flag( getotherteam( self.team ) );
|
||||
@ -113,36 +102,33 @@ bot_should_patrol_flag()
|
||||
return 0;
|
||||
}
|
||||
|
||||
ctf_get_flag( team )
|
||||
ctf_get_flag( team ) //checked changed to match cerberus output
|
||||
{
|
||||
_a115 = level.flags;
|
||||
_k115 = getFirstArrayKey( _a115 );
|
||||
while ( isDefined( _k115 ) )
|
||||
foreach ( f in level.flags )
|
||||
{
|
||||
f = _a115[ _k115 ];
|
||||
if ( f maps/mp/gametypes/_gameobjects::getownerteam() == team )
|
||||
{
|
||||
return f;
|
||||
}
|
||||
_k115 = getNextArrayKey( _a115, _k115 );
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
ctf_flag_get_home()
|
||||
ctf_flag_get_home() //checked matches cerberus output
|
||||
{
|
||||
return self.trigger.baseorigin;
|
||||
}
|
||||
|
||||
ctf_has_flag( flag )
|
||||
ctf_has_flag( flag ) //checked changed at own discretion
|
||||
{
|
||||
if ( isDefined( flag.carrier ) )
|
||||
if ( isDefined( flag.carrier ) && flag.carrier == self )
|
||||
{
|
||||
return flag.carrier == self;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bot_ctf_capture()
|
||||
bot_ctf_capture() //checked changed to match cerberus output
|
||||
{
|
||||
flag_enemy = ctf_get_flag( getotherteam( self.team ) );
|
||||
flag_mine = ctf_get_flag( self.team );
|
||||
@ -173,16 +159,13 @@ bot_ctf_capture()
|
||||
self addgoal( flag_enemy.carrier.origin, 16, 3, "ctf_flag" );
|
||||
}
|
||||
}
|
||||
else
|
||||
else if ( self maps/mp/bots/_bot::bot_friend_goal_in_radius( "ctf_flag", flag_enemy.curorigin, 16 ) <= 1 )
|
||||
{
|
||||
if ( self maps/mp/bots/_bot::bot_friend_goal_in_radius( "ctf_flag", flag_enemy.curorigin, 16 ) <= 1 )
|
||||
{
|
||||
self addgoal( flag_enemy.curorigin, 16, 3, "ctf_flag" );
|
||||
}
|
||||
self addgoal( flag_enemy.curorigin, 16, 3, "ctf_flag" );
|
||||
}
|
||||
}
|
||||
|
||||
bot_ctf_defend()
|
||||
bot_ctf_defend() //checked changed to match cerberus output
|
||||
{
|
||||
flag_enemy = ctf_get_flag( getotherteam( self.team ) );
|
||||
flag_mine = ctf_get_flag( self.team );
|
||||
@ -203,24 +186,18 @@ bot_ctf_defend()
|
||||
return self bot_ctf_add_goal( flag_mine.curorigin, 4, "ctf_flag" );
|
||||
}
|
||||
}
|
||||
else
|
||||
else if ( !flag_enemy ishome() || distance2dsquared( self.origin, home_enemy ) > 250000 )
|
||||
{
|
||||
if ( !flag_enemy ishome() || distance2dsquared( self.origin, home_enemy ) > 250000 )
|
||||
{
|
||||
return self bot_ctf_add_goal( flag_mine.curorigin, 4, "ctf_flag" );
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( self maps/mp/bots/_bot::bot_friend_goal_in_radius( "ctf_flag", home_enemy, 16 ) <= 1 )
|
||||
{
|
||||
self addgoal( home_enemy, 16, 4, "ctf_flag" );
|
||||
}
|
||||
}
|
||||
return self bot_ctf_add_goal( flag_mine.curorigin, 4, "ctf_flag" );
|
||||
}
|
||||
else if ( self maps/mp/bots/_bot::bot_friend_goal_in_radius( "ctf_flag", home_enemy, 16 ) <= 1 )
|
||||
{
|
||||
self addgoal( home_enemy, 16, 4, "ctf_flag" );
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
bot_ctf_add_goal( origin, goal_priority, goal_name )
|
||||
bot_ctf_add_goal( origin, goal_priority, goal_name ) //checked matches cerberus output
|
||||
{
|
||||
goal = undefined;
|
||||
if ( findpath( self.origin, origin, undefined, 0, 1 ) )
|
||||
@ -247,7 +224,7 @@ bot_ctf_add_goal( origin, goal_priority, goal_name )
|
||||
return 0;
|
||||
}
|
||||
|
||||
bot_get_look_at()
|
||||
bot_get_look_at() //checked matches cerberus output
|
||||
{
|
||||
enemy = self maps/mp/bots/_bot::bot_get_closest_enemy( self.origin, 1 );
|
||||
if ( isDefined( enemy ) )
|
||||
@ -276,7 +253,7 @@ bot_get_look_at()
|
||||
return home_mine;
|
||||
}
|
||||
|
||||
bot_patrol_flag()
|
||||
bot_patrol_flag() //checked changed to match cerberus output
|
||||
{
|
||||
self cancelgoal( "ctf_flag" );
|
||||
flag_mine = ctf_get_flag( self.team );
|
||||
@ -356,11 +333,12 @@ bot_patrol_flag()
|
||||
return;
|
||||
}
|
||||
nodes = getvisiblenodes( nearest );
|
||||
/*
|
||||
/#
|
||||
assert( nodes.size );
|
||||
#/
|
||||
i = randomint( nodes.size );
|
||||
while ( i < nodes.size )
|
||||
*/
|
||||
for ( i = randomint(nodes.size); i < nodes.size; i++ )
|
||||
{
|
||||
if ( self maps/mp/bots/_bot::bot_friend_goal_in_radius( "ctf_flag_patrol", nodes[ i ].origin, 256 ) == 0 )
|
||||
{
|
||||
@ -368,37 +346,37 @@ bot_patrol_flag()
|
||||
self.bot.update_objective_patrol = getTime() + randomintrange( 3000, 6000 );
|
||||
return;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
base_nearest_node( flag )
|
||||
base_nearest_node( flag ) //checked matches cerberus output
|
||||
{
|
||||
home = flag ctf_flag_get_home();
|
||||
nodes = getnodesinradiussorted( home, 256, 0 );
|
||||
/*
|
||||
/#
|
||||
assert( nodes.size );
|
||||
#/
|
||||
*/
|
||||
return nodes[ 0 ];
|
||||
}
|
||||
|
||||
bot_ctf_random_visible_node( origin )
|
||||
bot_ctf_random_visible_node( origin ) //checked changed to match cerberus output
|
||||
{
|
||||
nodes = getnodesinradius( origin, 384, 0, 256 );
|
||||
nearest = maps/mp/bots/_bot_combat::bot_nearest_node( origin );
|
||||
while ( isDefined( nearest ) && nodes.size )
|
||||
if ( isDefined( nearest ) && nodes.size )
|
||||
{
|
||||
current = randomintrange( 0, nodes.size );
|
||||
i = 0;
|
||||
while ( i < nodes.size )
|
||||
for ( i = 0; i < nodes.size; i++ )
|
||||
{
|
||||
current = ( current + 1 ) % nodes.size;
|
||||
if ( nodesvisible( nodes[ current ], nearest ) )
|
||||
{
|
||||
return nodes[ current ];
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
|
||||
@ -1,20 +1,18 @@
|
||||
//checked changed includes to match cerberus output
|
||||
#include maps/mp/bots/_bot;
|
||||
#include maps/mp/bots/_bot_combat;
|
||||
#include maps/mp/_utility;
|
||||
#include common_scripts/utility;
|
||||
#include maps/mp/gametypes/dem;
|
||||
|
||||
bot_dem_think()
|
||||
bot_dem_think() //checked changed to match cerberus output
|
||||
{
|
||||
while ( !isDefined( level.bombzones[ 0 ].dem_nodes ) )
|
||||
if ( !isDefined( level.bombzones[ 0 ].dem_nodes ) )
|
||||
{
|
||||
_a11 = level.bombzones;
|
||||
_k11 = getFirstArrayKey( _a11 );
|
||||
while ( isDefined( _k11 ) )
|
||||
foreach ( zone in level.bombzones )
|
||||
{
|
||||
zone = _a11[ _k11 ];
|
||||
zone.dem_nodes = [];
|
||||
zone.dem_nodes = getnodesinradius( zone.trigger.origin, 1024, 64, 128, "Path" );
|
||||
_k11 = getNextArrayKey( _a11, _k11 );
|
||||
}
|
||||
}
|
||||
if ( self.team == game[ "attackers" ] )
|
||||
@ -27,55 +25,45 @@ bot_dem_think()
|
||||
}
|
||||
}
|
||||
|
||||
bot_dem_attack_think()
|
||||
bot_dem_attack_think() //checked partially changed to match cerberus output changed at own discretion
|
||||
{
|
||||
zones = dem_get_alive_zones();
|
||||
if ( !zones.size )
|
||||
{
|
||||
return;
|
||||
}
|
||||
while ( !isDefined( self.goal_flag ) )
|
||||
if ( !isDefined( self.goal_flag ) )
|
||||
{
|
||||
zones = array_randomize( zones );
|
||||
_a42 = zones;
|
||||
_k42 = getFirstArrayKey( _a42 );
|
||||
while ( isDefined( _k42 ) )
|
||||
foreach ( zone in zones )
|
||||
{
|
||||
zone = _a42[ _k42 ];
|
||||
if ( zones.size == 1 || is_true( zone.bombplanted ) && !is_true( zone.bombexploded ) )
|
||||
{
|
||||
self.goal_flag = zone;
|
||||
break;
|
||||
}
|
||||
else if ( randomint( 100 ) < 50 )
|
||||
if ( randomint( 100 ) < 50 )
|
||||
{
|
||||
self.goal_flag = zone;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
_k42 = getNextArrayKey( _a42, _k42 );
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( isDefined( self.goal_flag ) )
|
||||
else if ( isDefined( self.goal_flag ) )
|
||||
{
|
||||
if ( is_true( self.goal_flag.bombexploded ) )
|
||||
{
|
||||
self.goal_flag = undefined;
|
||||
self cancelgoal( "dem_guard" );
|
||||
self cancelgoal( "bomb" );
|
||||
return;
|
||||
}
|
||||
else if ( is_true( self.goal_flag.bombplanted ) )
|
||||
{
|
||||
self bot_dem_guard( self.goal_flag, self.goal_flag.dem_nodes, self.goal_flag.trigger.origin );
|
||||
return;
|
||||
}
|
||||
else if ( self bot_dem_friend_interacting( self.goal_flag.trigger.origin ) )
|
||||
{
|
||||
self bot_dem_guard( self.goal_flag, self.goal_flag.dem_nodes, self.goal_flag.trigger.origin );
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -84,50 +72,41 @@ bot_dem_attack_think()
|
||||
}
|
||||
}
|
||||
|
||||
bot_dem_defend_think()
|
||||
bot_dem_defend_think() //checked partially changed to match cerberus output changed at own discretion
|
||||
{
|
||||
zones = dem_get_alive_zones();
|
||||
if ( !zones.size )
|
||||
{
|
||||
return;
|
||||
}
|
||||
while ( !isDefined( self.goal_flag ) )
|
||||
if ( !isDefined( self.goal_flag ) )
|
||||
{
|
||||
zones = array_randomize( zones );
|
||||
_a95 = zones;
|
||||
_k95 = getFirstArrayKey( _a95 );
|
||||
while ( isDefined( _k95 ) )
|
||||
foreach ( zone in zones )
|
||||
{
|
||||
zone = _a95[ _k95 ];
|
||||
if ( zones.size == 1 || is_true( zone.bombplanted ) && !is_true( zone.bombexploded ) )
|
||||
{
|
||||
self.goal_flag = zone;
|
||||
break;
|
||||
}
|
||||
else if ( randomint( 100 ) < 50 )
|
||||
if ( randomint( 100 ) < 50 )
|
||||
{
|
||||
self.goal_flag = zone;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
_k95 = getNextArrayKey( _a95, _k95 );
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( isDefined( self.goal_flag ) )
|
||||
else if ( isDefined( self.goal_flag ) )
|
||||
{
|
||||
if ( is_true( self.goal_flag.bombexploded ) )
|
||||
{
|
||||
self.goal_flag = undefined;
|
||||
self cancelgoal( "dem_guard" );
|
||||
self cancelgoal( "bomb" );
|
||||
return;
|
||||
}
|
||||
else if ( is_true( self.goal_flag.bombplanted ) && !self bot_dem_friend_interacting( self.goal_flag.trigger.origin ) )
|
||||
{
|
||||
self bot_dem_defuse( self.goal_flag );
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -136,7 +115,7 @@ bot_dem_defend_think()
|
||||
}
|
||||
}
|
||||
|
||||
bot_dem_attack( zone )
|
||||
bot_dem_attack( zone ) //checked changed to match cerberus output
|
||||
{
|
||||
self cancelgoal( "dem_guard" );
|
||||
if ( !self hasgoal( "bomb" ) )
|
||||
@ -162,31 +141,27 @@ bot_dem_attack( zone )
|
||||
self addgoal( self.bomb_goal, 48, 4, "bomb" );
|
||||
self setstance( "prone" );
|
||||
self pressusebutton( level.planttime + 1 );
|
||||
wait 0,5;
|
||||
wait 0.5;
|
||||
if ( is_true( self.isplanting ) )
|
||||
{
|
||||
wait ( level.planttime + 1 );
|
||||
}
|
||||
self pressusebutton( 0 );
|
||||
defenders = self bot_get_enemies();
|
||||
_a172 = defenders;
|
||||
_k172 = getFirstArrayKey( _a172 );
|
||||
while ( isDefined( _k172 ) )
|
||||
foreach ( defender in defenders )
|
||||
{
|
||||
defender = _a172[ _k172 ];
|
||||
if ( defender is_bot() )
|
||||
{
|
||||
defender.goal_flag = undefined;
|
||||
}
|
||||
_k172 = getNextArrayKey( _a172, _k172 );
|
||||
}
|
||||
self setstance( "crouch" );
|
||||
wait 0,25;
|
||||
wait 0.25;
|
||||
self cancelgoal( "bomb" );
|
||||
self setstance( "stand" );
|
||||
}
|
||||
|
||||
bot_dem_guard( zone, nodes, origin )
|
||||
bot_dem_guard( zone, nodes, origin ) //checked matches cerberus output
|
||||
{
|
||||
self cancelgoal( "bomb" );
|
||||
enemy = self bot_dem_enemy_interacting( origin );
|
||||
@ -212,7 +187,7 @@ bot_dem_guard( zone, nodes, origin )
|
||||
self addgoal( node, 24, 2, "dem_guard" );
|
||||
}
|
||||
|
||||
bot_dem_defuse( zone )
|
||||
bot_dem_defuse( zone ) //checked matches cerberus output
|
||||
{
|
||||
self cancelgoal( "dem_guard" );
|
||||
if ( !self hasgoal( "bomb" ) )
|
||||
@ -249,65 +224,51 @@ bot_dem_defuse( zone )
|
||||
self setstance( "prone" );
|
||||
}
|
||||
self pressusebutton( level.defusetime + 1 );
|
||||
wait 0,5;
|
||||
wait 0.5;
|
||||
if ( is_true( self.isdefusing ) )
|
||||
{
|
||||
wait ( level.defusetime + 1 );
|
||||
}
|
||||
self pressusebutton( 0 );
|
||||
self setstance( "crouch" );
|
||||
wait 0,25;
|
||||
wait 0.25;
|
||||
self cancelgoal( "bomb" );
|
||||
self setstance( "stand" );
|
||||
}
|
||||
|
||||
bot_dem_enemy_interacting( origin )
|
||||
bot_dem_enemy_interacting( origin ) //checked partially changed to match cerberus output did not use continue see github for more info
|
||||
{
|
||||
enemies = maps/mp/bots/_bot::bot_get_enemies();
|
||||
_a288 = enemies;
|
||||
_k288 = getFirstArrayKey( _a288 );
|
||||
while ( isDefined( _k288 ) )
|
||||
foreach ( enemy in enemies )
|
||||
{
|
||||
enemy = _a288[ _k288 ];
|
||||
if ( distancesquared( enemy.origin, origin ) > 65536 )
|
||||
{
|
||||
}
|
||||
else
|
||||
else if ( is_true( enemy.isdefusing ) || is_true( enemy.isplanting ) )
|
||||
{
|
||||
if ( is_true( enemy.isdefusing ) || is_true( enemy.isplanting ) )
|
||||
{
|
||||
return enemy;
|
||||
}
|
||||
return enemy;
|
||||
}
|
||||
_k288 = getNextArrayKey( _a288, _k288 );
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
bot_dem_friend_interacting( origin )
|
||||
bot_dem_friend_interacting( origin ) //checked partially changed to match cerberus output did not use continue see github for more info
|
||||
{
|
||||
friends = maps/mp/bots/_bot::bot_get_friends();
|
||||
_a308 = friends;
|
||||
_k308 = getFirstArrayKey( _a308 );
|
||||
while ( isDefined( _k308 ) )
|
||||
foreach ( friend in friends )
|
||||
{
|
||||
friend = _a308[ _k308 ];
|
||||
if ( distancesquared( friend.origin, origin ) > 65536 )
|
||||
{
|
||||
}
|
||||
else
|
||||
else if ( is_true( friend.isdefusing ) || is_true( friend.isplanting ) )
|
||||
{
|
||||
if ( is_true( friend.isdefusing ) || is_true( friend.isplanting ) )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
_k308 = getNextArrayKey( _a308, _k308 );
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bot_dem_enemy_nearby( origin )
|
||||
bot_dem_enemy_nearby( origin ) //checked matches cerberus output
|
||||
{
|
||||
enemy = maps/mp/bots/_bot::bot_get_closest_enemy( origin, 1 );
|
||||
if ( isDefined( enemy ) )
|
||||
@ -320,14 +281,11 @@ bot_dem_enemy_nearby( origin )
|
||||
return undefined;
|
||||
}
|
||||
|
||||
dem_get_alive_zones()
|
||||
dem_get_alive_zones() //checked partially changed to match cerberus output did not use continue see github for more info
|
||||
{
|
||||
zones = [];
|
||||
_a343 = level.bombzones;
|
||||
_k343 = getFirstArrayKey( _a343 );
|
||||
while ( isDefined( _k343 ) )
|
||||
foreach ( zone in level.bombzones )
|
||||
{
|
||||
zone = _a343[ _k343 ];
|
||||
if ( is_true( zone.bombexploded ) )
|
||||
{
|
||||
}
|
||||
@ -335,14 +293,13 @@ dem_get_alive_zones()
|
||||
{
|
||||
zones[ zones.size ] = zone;
|
||||
}
|
||||
_k343 = getNextArrayKey( _a343, _k343 );
|
||||
}
|
||||
return zones;
|
||||
}
|
||||
|
||||
dem_get_bomb_goal( ent )
|
||||
dem_get_bomb_goal( ent ) //checked changed to match cerberus output
|
||||
{
|
||||
while ( !isDefined( ent.bot_goals ) )
|
||||
if ( !isDefined( ent.bot_goals ) )
|
||||
{
|
||||
goals = [];
|
||||
ent.bot_goals = [];
|
||||
@ -354,28 +311,21 @@ dem_get_bomb_goal( ent )
|
||||
dir = vectorScale( dir, 48 );
|
||||
goals[ 2 ] = ent.origin + dir;
|
||||
goals[ 3 ] = ent.origin - dir;
|
||||
_a375 = goals;
|
||||
_k375 = getFirstArrayKey( _a375 );
|
||||
while ( isDefined( _k375 ) )
|
||||
foreach ( goal in goals )
|
||||
{
|
||||
goal = _a375[ _k375 ];
|
||||
start = goal + vectorScale( ( 0, 0, 1 ), 128 );
|
||||
trace = bullettrace( start, goal, 0, undefined );
|
||||
ent.bot_goals[ ent.bot_goals.size ] = trace[ "position" ];
|
||||
_k375 = getNextArrayKey( _a375, _k375 );
|
||||
}
|
||||
}
|
||||
goals = array_randomize( ent.bot_goals );
|
||||
_a386 = goals;
|
||||
_k386 = getFirstArrayKey( _a386 );
|
||||
while ( isDefined( _k386 ) )
|
||||
foreach ( goal in goals )
|
||||
{
|
||||
goal = _a386[ _k386 ];
|
||||
if ( findpath( self.origin, goal, 0 ) )
|
||||
{
|
||||
return goal;
|
||||
}
|
||||
_k386 = getNextArrayKey( _a386, _k386 );
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
|
||||
@ -1,10 +1,11 @@
|
||||
//checked includes match cerberus output
|
||||
#include maps/mp/bots/_bot;
|
||||
#include maps/mp/bots/_bot_combat;
|
||||
#include maps/mp/_utility;
|
||||
#include common_scripts/utility;
|
||||
#include maps/mp/gametypes/dom;
|
||||
|
||||
bot_dom_think()
|
||||
bot_dom_think() //checked changed to match cerberus output
|
||||
{
|
||||
time = getTime();
|
||||
if ( time < self.bot.update_objective )
|
||||
@ -41,20 +42,17 @@ bot_dom_think()
|
||||
{
|
||||
self bot_move_to_flag( flag );
|
||||
}
|
||||
else
|
||||
else if ( !dom_is_game_start() )
|
||||
{
|
||||
if ( !dom_is_game_start() )
|
||||
{
|
||||
self bot_flag_grenade( flag );
|
||||
}
|
||||
if ( distancesquared( self.origin, flag.origin ) < ( flag.radius * flag.radius ) && self istouching( flag.useobj.trigger ) )
|
||||
{
|
||||
self bot_capture_flag( flag );
|
||||
}
|
||||
self bot_flag_grenade( flag );
|
||||
}
|
||||
if ( distancesquared( self.origin, flag.origin ) < ( flag.radius * flag.radius ) && self istouching( flag.useobj.trigger ) )
|
||||
{
|
||||
self bot_capture_flag( flag );
|
||||
}
|
||||
}
|
||||
|
||||
bot_move_to_flag( flag )
|
||||
bot_move_to_flag( flag ) //checked matches cerberus output
|
||||
{
|
||||
if ( level.script == "mp_frostbite" )
|
||||
{
|
||||
@ -64,19 +62,21 @@ bot_move_to_flag( flag )
|
||||
{
|
||||
nodes = getnodesinradius( flag.origin, flag.radius, 0 );
|
||||
}
|
||||
/*
|
||||
/#
|
||||
assert( nodes.size );
|
||||
#/
|
||||
*/
|
||||
node = random( nodes );
|
||||
self addgoal( node, 24, 3, "dom_flag" );
|
||||
}
|
||||
|
||||
bot_is_capturing_flag()
|
||||
bot_is_capturing_flag() //checked matches cerberus output
|
||||
{
|
||||
return self atgoal( "dom_flag" );
|
||||
}
|
||||
|
||||
bot_has_flag_goal( flag )
|
||||
bot_has_flag_goal( flag ) //checked matches cerberus output
|
||||
{
|
||||
origin = self getgoal( "dom_flag" );
|
||||
if ( isDefined( origin ) )
|
||||
@ -89,7 +89,7 @@ bot_has_flag_goal( flag )
|
||||
return 0;
|
||||
}
|
||||
|
||||
bot_has_no_goal()
|
||||
bot_has_no_goal() //checked matches cerberus output
|
||||
{
|
||||
origin = self getgoal( "dom_flag" );
|
||||
if ( isDefined( origin ) )
|
||||
@ -99,16 +99,13 @@ bot_has_no_goal()
|
||||
return 1;
|
||||
}
|
||||
|
||||
bot_goal_is_enemy_flag()
|
||||
bot_goal_is_enemy_flag() //checked changed to match cerberus output
|
||||
{
|
||||
origin = self getgoal( "dom_flag" );
|
||||
while ( isDefined( origin ) )
|
||||
if ( isDefined( origin ) )
|
||||
{
|
||||
_a130 = level.flags;
|
||||
_k130 = getFirstArrayKey( _a130 );
|
||||
while ( isDefined( _k130 ) )
|
||||
foreach(flag in level.flags)
|
||||
{
|
||||
flag = _a130[ _k130 ];
|
||||
if ( distancesquared( flag.origin, origin ) < ( flag.radius * flag.radius ) )
|
||||
{
|
||||
if ( flag getflagteam() != self.team || dom_is_flag_contested( flag ) )
|
||||
@ -116,13 +113,12 @@ bot_goal_is_enemy_flag()
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
_k130 = getNextArrayKey( _a130, _k130 );
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bot_flag_grenade( flag )
|
||||
bot_flag_grenade( flag ) //checked matches cerberus output
|
||||
{
|
||||
if ( flag getflagteam() != self.team )
|
||||
{
|
||||
@ -145,7 +141,7 @@ bot_flag_grenade( flag )
|
||||
}
|
||||
}
|
||||
|
||||
bot_get_look_at( flag )
|
||||
bot_get_look_at( flag ) //checked matches cerberus output
|
||||
{
|
||||
enemy = self maps/mp/bots/_bot::bot_get_closest_enemy( self.origin, 0 );
|
||||
if ( isDefined( enemy ) )
|
||||
@ -165,7 +161,7 @@ bot_get_look_at( flag )
|
||||
return flag.origin;
|
||||
}
|
||||
|
||||
bot_capture_flag( flag )
|
||||
bot_capture_flag( flag ) //checked changed to match cerberus output
|
||||
{
|
||||
time = getTime();
|
||||
if ( flag getflagteam() != self.team )
|
||||
@ -208,86 +204,77 @@ bot_capture_flag( flag )
|
||||
self setstance( "crouch" );
|
||||
}
|
||||
}
|
||||
else
|
||||
else if ( cointoss() && !bot_friend_in_radius( self.origin, 384 ) )
|
||||
{
|
||||
if ( cointoss() && !bot_friend_in_radius( self.origin, 384 ) )
|
||||
{
|
||||
self addgoal( self.origin, 24, 4, "dom_flag" );
|
||||
wait randomfloatrange( 0,5, 1 );
|
||||
self setstance( "prone" );
|
||||
self.bot.update_lookat += 5000;
|
||||
}
|
||||
self addgoal( self.origin, 24, 4, "dom_flag" );
|
||||
wait randomfloatrange( 0.5, 1 );
|
||||
self setstance( "prone" );
|
||||
self.bot.update_lookat += 5000;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
else if ( !dom_is_game_start() )
|
||||
{
|
||||
if ( !dom_is_game_start() )
|
||||
if ( self getstance() == "stand" )
|
||||
{
|
||||
if ( self getstance() == "stand" )
|
||||
{
|
||||
wait randomfloatrange( 0,5, 1 );
|
||||
self setstance( "crouch" );
|
||||
}
|
||||
wait randomfloatrange( 0.5, 1 );
|
||||
self setstance( "crouch" );
|
||||
}
|
||||
}
|
||||
}
|
||||
else self clearlookat();
|
||||
self cancelgoal( "dom_flag" );
|
||||
if ( self getstance() == "crouch" )
|
||||
else
|
||||
{
|
||||
self setstance( "stand" );
|
||||
wait 0,25;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( self getstance() == "prone" )
|
||||
self clearlookat();
|
||||
self cancelgoal( "dom_flag" );
|
||||
if ( self getstance() == "crouch" )
|
||||
{
|
||||
self setstance( "stand" );
|
||||
wait 0.25;
|
||||
}
|
||||
else if ( self getstance() == "prone" )
|
||||
{
|
||||
self setstance( "crouch" );
|
||||
wait 0,25;
|
||||
wait 0.25;
|
||||
self setstance( "stand" );
|
||||
wait 0,25;
|
||||
wait 0.25;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dom_is_game_start()
|
||||
dom_is_game_start() //checked changed to match cerberus output
|
||||
{
|
||||
/*
|
||||
/#
|
||||
assert( isDefined( level.flags ) );
|
||||
#/
|
||||
_a289 = level.flags;
|
||||
_k289 = getFirstArrayKey( _a289 );
|
||||
while ( isDefined( _k289 ) )
|
||||
*/
|
||||
foreach ( flag in level.flags )
|
||||
{
|
||||
flag = _a289[ _k289 ];
|
||||
if ( flag getflagteam() != "neutral" )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
_k289 = getNextArrayKey( _a289, _k289 );
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
dom_get_closest_flag()
|
||||
dom_get_closest_flag() //checked matches cerberus output
|
||||
{
|
||||
flags = arraysort( level.flags, self.origin );
|
||||
return flags[ 0 ];
|
||||
}
|
||||
|
||||
dom_get_weighted_flag( owner )
|
||||
dom_get_weighted_flag( owner ) //checked partially changed to match cerberus output did not use continue see github for more info
|
||||
{
|
||||
/*
|
||||
/#
|
||||
assert( isDefined( level.flags ) );
|
||||
#/
|
||||
*/
|
||||
best = undefined;
|
||||
distsq = 9999999;
|
||||
_a313 = level.flags;
|
||||
_k313 = getFirstArrayKey( _a313 );
|
||||
while ( isDefined( _k313 ) )
|
||||
foreach ( flag in level.flags )
|
||||
{
|
||||
flag = _a313[ _k313 ];
|
||||
if ( isDefined( owner ) && flag getflagteam() != owner )
|
||||
{
|
||||
}
|
||||
@ -300,23 +287,21 @@ dom_get_weighted_flag( owner )
|
||||
distsq = d;
|
||||
}
|
||||
}
|
||||
_k313 = getNextArrayKey( _a313, _k313 );
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
dom_get_weighted_enemy_flag( team )
|
||||
dom_get_weighted_enemy_flag( team ) //checked partially changed to match cerberus output did not use continue see github for more info
|
||||
{
|
||||
/*
|
||||
/#
|
||||
assert( isDefined( level.flags ) );
|
||||
#/
|
||||
*/
|
||||
best = undefined;
|
||||
distsq = 9999999;
|
||||
_a339 = level.flags;
|
||||
_k339 = getFirstArrayKey( _a339 );
|
||||
while ( isDefined( _k339 ) )
|
||||
foreach ( flag in level.flags )
|
||||
{
|
||||
flag = _a339[ _k339 ];
|
||||
if ( flag getflagteam() == team )
|
||||
{
|
||||
}
|
||||
@ -329,28 +314,25 @@ dom_get_weighted_enemy_flag( team )
|
||||
distsq = d;
|
||||
}
|
||||
}
|
||||
_k339 = getNextArrayKey( _a339, _k339 );
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
dom_is_flag_contested( flag )
|
||||
dom_is_flag_contested( flag ) //checked changed at own discretion
|
||||
{
|
||||
enemy = self maps/mp/bots/_bot::bot_get_closest_enemy( flag.origin, 0 );
|
||||
if ( isDefined( enemy ) )
|
||||
if ( isDefined( enemy ) && distancesquared( enemy.origin, flag.origin ) < 147456 )
|
||||
{
|
||||
return distancesquared( enemy.origin, flag.origin ) < 147456;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
dom_has_two_flags( team )
|
||||
dom_has_two_flags( team ) //checked partially changed to match cerberus output did not use continue see github for more info
|
||||
{
|
||||
count = 0;
|
||||
_a368 = level.flags;
|
||||
_k368 = getFirstArrayKey( _a368 );
|
||||
while ( isDefined( _k368 ) )
|
||||
foreach ( flag in level.flags )
|
||||
{
|
||||
flag = _a368[ _k368 ];
|
||||
if ( dom_is_flag_contested( flag ) )
|
||||
{
|
||||
}
|
||||
@ -361,23 +343,21 @@ dom_has_two_flags( team )
|
||||
count++;
|
||||
}
|
||||
}
|
||||
_k368 = getNextArrayKey( _a368, _k368 );
|
||||
}
|
||||
return count >= 2;
|
||||
}
|
||||
|
||||
dom_get_weighted_contested_flag( team )
|
||||
dom_get_weighted_contested_flag( team ) //checked partially changed to match cerberus output did not use continue see github for more info
|
||||
{
|
||||
/*
|
||||
/#
|
||||
assert( isDefined( level.flags ) );
|
||||
#/
|
||||
*/
|
||||
best = undefined;
|
||||
distsq = 9999999;
|
||||
_a391 = level.flags;
|
||||
_k391 = getFirstArrayKey( _a391 );
|
||||
while ( isDefined( _k391 ) )
|
||||
foreach ( flag in level.flags )
|
||||
{
|
||||
flag = _a391[ _k391 ];
|
||||
if ( !dom_is_flag_contested( flag ) )
|
||||
{
|
||||
}
|
||||
@ -390,35 +370,34 @@ dom_get_weighted_contested_flag( team )
|
||||
distsq = d;
|
||||
}
|
||||
}
|
||||
_k391 = getNextArrayKey( _a391, _k391 );
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
dom_get_random_flag( owner )
|
||||
dom_get_random_flag( owner ) //checked changed to match cerberus output
|
||||
{
|
||||
/*
|
||||
/#
|
||||
assert( isDefined( level.flags ) );
|
||||
#/
|
||||
*/
|
||||
flagindex = randomintrange( 0, level.flags.size );
|
||||
if ( !isDefined( owner ) )
|
||||
{
|
||||
return level.flags[ flagindex ];
|
||||
}
|
||||
i = 0;
|
||||
while ( i < level.flags.size )
|
||||
for ( i = 0; i < level.flags.size; i++ )
|
||||
{
|
||||
if ( level.flags[ flagindex ] getflagteam() == owner )
|
||||
{
|
||||
return level.flags[ flagindex ];
|
||||
}
|
||||
flagindex = ( flagindex + 1 ) % level.flags.size;
|
||||
i++;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
dom_get_best_flag( team )
|
||||
dom_get_best_flag( team ) //checked matches cerberus output
|
||||
{
|
||||
flag1 = dom_get_weighted_enemy_flag( team );
|
||||
flag2 = dom_get_weighted_contested_flag( team );
|
||||
@ -452,7 +431,7 @@ dom_get_best_flag( team )
|
||||
}
|
||||
}
|
||||
|
||||
bot_tactical_insertion( flag )
|
||||
bot_tactical_insertion( flag ) //checked matches cerberus output
|
||||
{
|
||||
if ( self getweaponammostock( "tactical_insertion_mp" ) <= 0 )
|
||||
{
|
||||
@ -481,3 +460,4 @@ bot_tactical_insertion( flag )
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -3,14 +3,11 @@
|
||||
#include common_scripts/utility;
|
||||
#include maps/mp/gametypes/ctf;
|
||||
|
||||
bot_hack_tank_get_goal_origin( tank )
|
||||
bot_hack_tank_get_goal_origin( tank ) //checked changed to match cerberus output
|
||||
{
|
||||
nodes = getnodesinradiussorted( tank.origin, 256, 0, 64, "Path" );
|
||||
_a11 = nodes;
|
||||
_k11 = getFirstArrayKey( _a11 );
|
||||
while ( isDefined( _k11 ) )
|
||||
foreach ( node in nodes )
|
||||
{
|
||||
node = _a11[ _k11 ];
|
||||
dir = vectornormalize( node.origin - tank.origin );
|
||||
dir = vectorScale( dir, 32 );
|
||||
goal = tank.origin + dir;
|
||||
@ -18,12 +15,11 @@ bot_hack_tank_get_goal_origin( tank )
|
||||
{
|
||||
return goal;
|
||||
}
|
||||
_k11 = getNextArrayKey( _a11, _k11 );
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
bot_hack_has_goal( tank )
|
||||
bot_hack_has_goal( tank ) //checked matches cerberus output
|
||||
{
|
||||
goal = self getgoal( "hack" );
|
||||
if ( isDefined( goal ) )
|
||||
@ -36,22 +32,19 @@ bot_hack_has_goal( tank )
|
||||
return 0;
|
||||
}
|
||||
|
||||
bot_hack_at_goal()
|
||||
bot_hack_at_goal() //checked changed to match cerberus output
|
||||
{
|
||||
if ( self atgoal( "hack" ) )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
goal = self getgoal( "hack" );
|
||||
while ( isDefined( goal ) )
|
||||
if ( isDefined( goal ) )
|
||||
{
|
||||
tanks = getentarray( "talon", "targetname" );
|
||||
tanks = arraysort( tanks, self.origin );
|
||||
_a56 = tanks;
|
||||
_k56 = getFirstArrayKey( _a56 );
|
||||
while ( isDefined( _k56 ) )
|
||||
foreach ( tank in tanks )
|
||||
{
|
||||
tank = _a56[ _k56 ];
|
||||
if ( distancesquared( goal, tank.origin ) < 16384 )
|
||||
{
|
||||
if ( isDefined( tank.trigger ) && self istouching( tank.trigger ) )
|
||||
@ -59,47 +52,45 @@ bot_hack_at_goal()
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
_k56 = getNextArrayKey( _a56, _k56 );
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bot_hack_goal_pregame( tanks )
|
||||
bot_hack_goal_pregame( tanks ) //checked partially changed to match cerberus output did not use foreach see github for more info
|
||||
{
|
||||
_a73 = tanks;
|
||||
_k73 = getFirstArrayKey( _a73 );
|
||||
while ( isDefined( _k73 ) )
|
||||
i = 0;
|
||||
while ( i < tanks.size )
|
||||
{
|
||||
tank = _a73[ _k73 ];
|
||||
if ( isDefined( tank.owner ) )
|
||||
if ( isDefined( tanks[ i ].owner ) )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
else if ( isDefined( tank.team ) && tank.team == self.team )
|
||||
if ( isDefined( tanks[ i ].team ) && tanks[ i ].team == self.team )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
else
|
||||
goal = self bot_hack_tank_get_goal_origin( tanks[ i ] );
|
||||
if ( isDefined( goal ) )
|
||||
{
|
||||
goal = self bot_hack_tank_get_goal_origin( tank );
|
||||
if ( isDefined( goal ) )
|
||||
if ( self addgoal( goal, 24, 2, "hack" ) )
|
||||
{
|
||||
if ( self addgoal( goal, 24, 2, "hack" ) )
|
||||
{
|
||||
self.goal_flag = tank;
|
||||
return;
|
||||
}
|
||||
self.goal_flag = tanks[ i ];
|
||||
return;
|
||||
}
|
||||
}
|
||||
_k73 = getNextArrayKey( _a73, _k73 );
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
bot_hack_think()
|
||||
bot_hack_think() //checked partially changed to match cerberus output did not us foreach see github for more info
|
||||
{
|
||||
if ( bot_hack_at_goal() )
|
||||
{
|
||||
self setstance( "crouch" );
|
||||
wait 0,25;
|
||||
wait 0.25;
|
||||
self addgoal( self.origin, 24, 4, "hack" );
|
||||
self pressusebutton( level.drone_hack_time + 1 );
|
||||
wait ( level.drone_hack_time + 1 );
|
||||
@ -112,91 +103,77 @@ bot_hack_think()
|
||||
{
|
||||
self bot_hack_goal_pregame( tanks );
|
||||
}
|
||||
else
|
||||
i = 0;
|
||||
while ( i < tanks.size )
|
||||
{
|
||||
_a122 = tanks;
|
||||
_k122 = getFirstArrayKey( _a122 );
|
||||
while ( isDefined( _k122 ) )
|
||||
if ( isDefined( tanks[ i ].owner ) && tanks[ i ].owner == self )
|
||||
{
|
||||
tank = _a122[ _k122 ];
|
||||
if ( isDefined( tank.owner ) && tank.owner == self )
|
||||
{
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( !isDefined( tank.owner ) )
|
||||
{
|
||||
if ( self bot_hack_has_goal( tank ) )
|
||||
{
|
||||
return;
|
||||
}
|
||||
goal = self bot_hack_tank_get_goal_origin( tank );
|
||||
if ( isDefined( goal ) )
|
||||
{
|
||||
self addgoal( goal, 24, 2, "hack" );
|
||||
return;
|
||||
}
|
||||
}
|
||||
if ( tank.isstunned && distancesquared( self.origin, tank.origin ) < 262144 )
|
||||
{
|
||||
goal = self bot_hack_tank_get_goal_origin( tank );
|
||||
if ( isDefined( goal ) )
|
||||
{
|
||||
self addgoal( goal, 24, 3, "hack" );
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
_k122 = getNextArrayKey( _a122, _k122 );
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if ( !maps/mp/bots/_bot::bot_vehicle_weapon_ammo( "emp_grenade_mp" ) )
|
||||
if ( !isDefined( tanks[ i ].owner ) )
|
||||
{
|
||||
ammo = getentarray( "weapon_scavenger_item_hack_mp", "classname" );
|
||||
ammo = arraysort( ammo, self.origin );
|
||||
_a162 = ammo;
|
||||
_k162 = getFirstArrayKey( _a162 );
|
||||
while ( isDefined( _k162 ) )
|
||||
if ( self bot_hack_has_goal( tanks[ i ] ) )
|
||||
{
|
||||
bag = _a162[ _k162 ];
|
||||
if ( findpath( self.origin, bag.origin, 0 ) )
|
||||
{
|
||||
self addgoal( bag.origin, 24, 2, "hack" );
|
||||
return;
|
||||
}
|
||||
_k162 = getNextArrayKey( _a162, _k162 );
|
||||
return;
|
||||
}
|
||||
goal = self bot_hack_tank_get_goal_origin( tanks[ i ] );
|
||||
if ( isDefined( goal ) )
|
||||
{
|
||||
self addgoal( goal, 24, 2, "hack" );
|
||||
return;
|
||||
}
|
||||
return;
|
||||
}
|
||||
_a174 = tanks;
|
||||
_k174 = getFirstArrayKey( _a174 );
|
||||
while ( isDefined( _k174 ) )
|
||||
if ( tanks[ i ].isstunned && distancesquared( self.origin, tanks[ i ].origin ) < 262144 )
|
||||
{
|
||||
tank = _a174[ _k174 ];
|
||||
if ( isDefined( tank.owner ) && tank.owner == self )
|
||||
goal = self bot_hack_tank_get_goal_origin( tanks[ i ] );
|
||||
if ( isDefined( goal ) )
|
||||
{
|
||||
self addgoal( goal, 24, 3, "hack" );
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( tank.isstunned )
|
||||
{
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( self throwgrenade( "emp_grenade_mp", tank.origin ) )
|
||||
{
|
||||
self waittill( "grenade_fire" );
|
||||
goal = self bot_hack_tank_get_goal_origin( tank );
|
||||
if ( isDefined( goal ) )
|
||||
{
|
||||
self addgoal( goal, 24, 3, "hack" );
|
||||
wait 0,5;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
_k174 = getNextArrayKey( _a174, _k174 );
|
||||
}
|
||||
i++;
|
||||
}
|
||||
if ( !maps/mp/bots/_bot::bot_vehicle_weapon_ammo( "emp_grenade_mp" ) )
|
||||
{
|
||||
ammo = getentarray( "weapon_scavenger_item_hack_mp", "classname" );
|
||||
ammo = arraysort( ammo, self.origin );
|
||||
foreach ( bag in ammo )
|
||||
{
|
||||
if ( findpath( self.origin, bag.origin, 0 ) )
|
||||
{
|
||||
self addgoal( bag.origin, 24, 2, "hack" );
|
||||
return;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
i = 0;
|
||||
while ( i < tanks.size )
|
||||
{
|
||||
if ( isDefined( tanks[ i ].owner ) && tanks[ i ].owner == self )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if ( tanks[ i ].isstunned )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if ( self throwgrenade( "emp_grenade_mp", tanks[ i ].origin ) )
|
||||
{
|
||||
self waittill( "grenade_fire" );
|
||||
goal = self bot_hack_tank_get_goal_origin( tanks[ i ] );
|
||||
if ( isDefined( goal ) )
|
||||
{
|
||||
self addgoal( goal, 24, 3, "hack" );
|
||||
wait 0.5;
|
||||
return;
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,9 +1,11 @@
|
||||
//checked includes changed to match cerberus output
|
||||
#include maps/mp/bots/_bot;
|
||||
#include maps/mp/bots/_bot_combat;
|
||||
#include maps/mp/_utility;
|
||||
#include common_scripts/utility;
|
||||
#include maps/mp/gametypes/koth;
|
||||
|
||||
bot_hq_think()
|
||||
bot_hq_think() //checked changed to match cerberus output
|
||||
{
|
||||
time = getTime();
|
||||
if ( time < self.bot.update_objective )
|
||||
@ -15,12 +17,9 @@ bot_hq_think()
|
||||
{
|
||||
self bot_patrol_hq();
|
||||
}
|
||||
else
|
||||
else if ( !bot_has_hq_goal() )
|
||||
{
|
||||
if ( !bot_has_hq_goal() )
|
||||
{
|
||||
self bot_move_to_hq();
|
||||
}
|
||||
self bot_move_to_hq();
|
||||
}
|
||||
if ( self bot_is_capturing_hq() )
|
||||
{
|
||||
@ -39,32 +38,28 @@ bot_hq_think()
|
||||
}
|
||||
}
|
||||
|
||||
bot_has_hq_goal()
|
||||
bot_has_hq_goal() //checked changed to match cerberus output
|
||||
{
|
||||
origin = self getgoal( "hq_radio" );
|
||||
while ( isDefined( origin ) )
|
||||
if ( isDefined( origin ) )
|
||||
{
|
||||
_a53 = level.radio.nodes;
|
||||
_k53 = getFirstArrayKey( _a53 );
|
||||
while ( isDefined( _k53 ) )
|
||||
foreach ( node in level.radio.nodes )
|
||||
{
|
||||
node = _a53[ _k53 ];
|
||||
if ( distancesquared( origin, node.origin ) < 4096 )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
_k53 = getNextArrayKey( _a53, _k53 );
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bot_is_capturing_hq()
|
||||
bot_is_capturing_hq() //checked matches cerberus output
|
||||
{
|
||||
return self atgoal( "hq_radio" );
|
||||
}
|
||||
|
||||
bot_should_patrol_hq()
|
||||
bot_should_patrol_hq() //checked matches cerberus output
|
||||
{
|
||||
if ( level.radio.gameobject.ownerteam == "neutral" )
|
||||
{
|
||||
@ -81,7 +76,7 @@ bot_should_patrol_hq()
|
||||
return 1;
|
||||
}
|
||||
|
||||
bot_patrol_hq()
|
||||
bot_patrol_hq() //checked changed to match cerberus output
|
||||
{
|
||||
self cancelgoal( "hq_radio" );
|
||||
if ( self atgoal( "hq_patrol" ) )
|
||||
@ -150,11 +145,12 @@ bot_patrol_hq()
|
||||
return;
|
||||
}
|
||||
nodes = getvisiblenodes( nearest );
|
||||
/*
|
||||
/#
|
||||
assert( nodes.size );
|
||||
#/
|
||||
i = randomint( nodes.size );
|
||||
while ( i < nodes.size )
|
||||
*/
|
||||
for ( i = randomint( nodes.size ); i < nodes.size; i++ )
|
||||
{
|
||||
if ( self maps/mp/bots/_bot::bot_friend_goal_in_radius( "hq_radio", nodes[ i ].origin, 128 ) == 0 )
|
||||
{
|
||||
@ -164,11 +160,10 @@ bot_patrol_hq()
|
||||
return;
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
bot_move_to_hq()
|
||||
bot_move_to_hq() //checked changed to match cerberus output
|
||||
{
|
||||
self clearlookat();
|
||||
self cancelgoal( "hq_radio" );
|
||||
@ -176,30 +171,26 @@ bot_move_to_hq()
|
||||
if ( self getstance() == "prone" )
|
||||
{
|
||||
self setstance( "crouch" );
|
||||
wait 0,25;
|
||||
wait 0.25;
|
||||
}
|
||||
if ( self getstance() == "crouch" )
|
||||
{
|
||||
self setstance( "stand" );
|
||||
wait 0,25;
|
||||
wait 0.25;
|
||||
}
|
||||
nodes = array_randomize( level.radio.nodes );
|
||||
_a219 = nodes;
|
||||
_k219 = getFirstArrayKey( _a219 );
|
||||
while ( isDefined( _k219 ) )
|
||||
foreach ( node in nodes )
|
||||
{
|
||||
node = _a219[ _k219 ];
|
||||
if ( self maps/mp/bots/_bot::bot_friend_goal_in_radius( "hq_radio", node.origin, 64 ) == 0 )
|
||||
{
|
||||
self addgoal( node, 24, 3, "hq_radio" );
|
||||
return;
|
||||
}
|
||||
_k219 = getNextArrayKey( _a219, _k219 );
|
||||
}
|
||||
self addgoal( random( nodes ), 24, 3, "hq_radio" );
|
||||
}
|
||||
|
||||
bot_get_look_at()
|
||||
bot_get_look_at() //checked matches cerberus output
|
||||
{
|
||||
enemy = self maps/mp/bots/_bot::bot_get_closest_enemy( self.origin, 1 );
|
||||
if ( isDefined( enemy ) )
|
||||
@ -232,7 +223,7 @@ bot_get_look_at()
|
||||
return level.radio.baseorigin;
|
||||
}
|
||||
|
||||
bot_capture_hq()
|
||||
bot_capture_hq() //checked matches cerberus output
|
||||
{
|
||||
self addgoal( self.origin, 24, 3, "hq_radio" );
|
||||
self setstance( "crouch" );
|
||||
@ -256,13 +247,10 @@ bot_capture_hq()
|
||||
}
|
||||
}
|
||||
|
||||
any_other_team_touching( skip_team )
|
||||
any_other_team_touching( skip_team ) //checked partially changed to match cerberus output did not use continue see github for more info
|
||||
{
|
||||
_a307 = level.teams;
|
||||
_k307 = getFirstArrayKey( _a307 );
|
||||
while ( isDefined( _k307 ) )
|
||||
foreach ( team in level.teams )
|
||||
{
|
||||
team = _a307[ _k307 ];
|
||||
if ( team == skip_team )
|
||||
{
|
||||
}
|
||||
@ -273,12 +261,11 @@ any_other_team_touching( skip_team )
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
_k307 = getNextArrayKey( _a307, _k307 );
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
is_hq_contested( skip_team )
|
||||
is_hq_contested( skip_team ) //checked matches cerberus output
|
||||
{
|
||||
if ( any_other_team_touching( skip_team ) )
|
||||
{
|
||||
@ -292,7 +279,7 @@ is_hq_contested( skip_team )
|
||||
return 0;
|
||||
}
|
||||
|
||||
bot_hq_grenade()
|
||||
bot_hq_grenade() //checked matches cerberus output
|
||||
{
|
||||
enemies = bot_get_enemies();
|
||||
if ( !enemies.size )
|
||||
@ -333,7 +320,7 @@ bot_hq_grenade()
|
||||
}
|
||||
}
|
||||
|
||||
bot_hq_tactical_insertion()
|
||||
bot_hq_tactical_insertion() //checked matches cerberus output
|
||||
{
|
||||
if ( !self hasweapon( "tactical_insertion_mp" ) )
|
||||
{
|
||||
@ -358,16 +345,18 @@ bot_hq_tactical_insertion()
|
||||
}
|
||||
}
|
||||
|
||||
hq_nearest_node()
|
||||
hq_nearest_node() //checked matches cerberus output
|
||||
{
|
||||
return random( level.radio.nodes );
|
||||
}
|
||||
|
||||
hq_is_contested()
|
||||
hq_is_contested() //checked changed at own discretion
|
||||
{
|
||||
enemy = self maps/mp/bots/_bot::bot_get_closest_enemy( level.radio.baseorigin, 0 );
|
||||
if ( isDefined( enemy ) )
|
||||
if ( isDefined( enemy ) && distancesquared( enemy.origin, level.radio.baseorigin ) < ( level.radio.node_radius * level.radio.node_radius ) )
|
||||
{
|
||||
return distancesquared( enemy.origin, level.radio.baseorigin ) < ( level.radio.node_radius * level.radio.node_radius );
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -1,18 +1,21 @@
|
||||
#include maps/mp/bots/_bot_combat;
|
||||
#include maps/mp/bots/_bot;
|
||||
#include maps/mp/_utility;
|
||||
#include common_scripts/utility;
|
||||
#include maps/mp/gametypes/koth;
|
||||
|
||||
bot_koth_think()
|
||||
bot_koth_think() //checked matches cerberus output
|
||||
{
|
||||
if ( !isDefined( level.zone.trig.goal_radius ) )
|
||||
{
|
||||
maxs = level.zone.trig getmaxs();
|
||||
maxs = level.zone.trig.origin + maxs;
|
||||
level.zone.trig.goal_radius = distance( level.zone.trig.origin, maxs );
|
||||
/*
|
||||
/#
|
||||
println( "distance: " + level.zone.trig.goal_radius );
|
||||
#/
|
||||
*/
|
||||
ground = bullettrace( level.zone.gameobject.curorigin, level.zone.gameobject.curorigin - vectorScale( ( 0, 0, 1 ), 1024 ), 0, undefined );
|
||||
level.zone.trig.goal = ground[ "position" ] + vectorScale( ( 0, 0, 1 ), 8 );
|
||||
}
|
||||
@ -28,12 +31,12 @@ bot_koth_think()
|
||||
bot_hill_grenade();
|
||||
}
|
||||
|
||||
bot_has_hill_goal()
|
||||
bot_has_hill_goal() //checked matches cerberus output
|
||||
{
|
||||
origin = self getgoal( "koth_hill" );
|
||||
if ( isDefined( origin ) )
|
||||
{
|
||||
if ( distance2dsquared( level.zone.gameobject.curorigin, origin ) < ( level.zone.trig.goal_radius * level.zone.trig.goal_radius ) )
|
||||
if ( distance2dsquared( level.zone.gameobject.curorigin, origin ) < level.zone.trig.goal_radius * level.zone.trig.goal_radius )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
@ -41,12 +44,12 @@ bot_has_hill_goal()
|
||||
return 0;
|
||||
}
|
||||
|
||||
bot_is_at_hill()
|
||||
bot_is_at_hill() //checked matches cerberus output
|
||||
{
|
||||
return self atgoal( "koth_hill" );
|
||||
}
|
||||
|
||||
bot_move_to_hill()
|
||||
bot_move_to_hill() //checked changed to match cerberus output
|
||||
{
|
||||
if ( getTime() < ( self.bot.update_objective + 4000 ) )
|
||||
{
|
||||
@ -57,19 +60,16 @@ bot_move_to_hill()
|
||||
if ( self getstance() == "prone" )
|
||||
{
|
||||
self setstance( "crouch" );
|
||||
wait 0,25;
|
||||
wait 0.25;
|
||||
}
|
||||
if ( self getstance() == "crouch" )
|
||||
{
|
||||
self setstance( "stand" );
|
||||
wait 0,25;
|
||||
wait 0.25;
|
||||
}
|
||||
nodes = getnodesinradiussorted( level.zone.trig.goal, level.zone.trig.goal_radius, 0, 128 );
|
||||
_a80 = nodes;
|
||||
_k80 = getFirstArrayKey( _a80 );
|
||||
while ( isDefined( _k80 ) )
|
||||
foreach ( node in nodes )
|
||||
{
|
||||
node = _a80[ _k80 ];
|
||||
if ( self maps/mp/bots/_bot::bot_friend_goal_in_radius( "koth_hill", node.origin, 64 ) == 0 )
|
||||
{
|
||||
if ( findpath( self.origin, node.origin, self, 0, 1 ) )
|
||||
@ -79,11 +79,10 @@ bot_move_to_hill()
|
||||
return;
|
||||
}
|
||||
}
|
||||
_k80 = getNextArrayKey( _a80, _k80 );
|
||||
}
|
||||
}
|
||||
|
||||
bot_get_look_at()
|
||||
bot_get_look_at() //checked matches cerberus output
|
||||
{
|
||||
enemy = self maps/mp/bots/_bot::bot_get_closest_enemy( self.origin, 1 );
|
||||
if ( isDefined( enemy ) )
|
||||
@ -116,7 +115,7 @@ bot_get_look_at()
|
||||
return level.zone.gameobject.curorigin;
|
||||
}
|
||||
|
||||
bot_capture_hill()
|
||||
bot_capture_hill() //checked changed to match cerberus output
|
||||
{
|
||||
self addgoal( self.origin, 24, 3, "koth_hill" );
|
||||
self setstance( "crouch" );
|
||||
@ -136,11 +135,10 @@ bot_capture_hill()
|
||||
origin += dir;
|
||||
}
|
||||
self maps/mp/bots/_bot_combat::bot_combat_throw_proximity( origin );
|
||||
while ( cointoss() && lengthsquared( self getvelocity() ) < 2 )
|
||||
if ( cointoss() && lengthsquared( self getvelocity() ) < 2 )
|
||||
{
|
||||
nodes = getnodesinradius( level.zone.trig.goal, level.zone.trig.goal_radius + 128, 0, 128 );
|
||||
i = randomintrange( 0, nodes.size );
|
||||
while ( i < nodes.size )
|
||||
for ( i = randomintrange( 0, nodes.size ); i < nodes.size; i++ )
|
||||
{
|
||||
node = nodes[ i ];
|
||||
if ( distancesquared( node.origin, self.origin ) > 1024 )
|
||||
@ -155,39 +153,30 @@ bot_capture_hill()
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
self.bot.update_lookat = getTime() + randomintrange( 1500, 3000 );
|
||||
}
|
||||
}
|
||||
|
||||
any_other_team_touching( skip_team )
|
||||
any_other_team_touching( skip_team ) //checked partially changed to match cerberus output did not use foreach see github for more info
|
||||
{
|
||||
_a194 = level.teams;
|
||||
_k194 = getFirstArrayKey( _a194 );
|
||||
while ( isDefined( _k194 ) )
|
||||
teams = getArrayKeys( level.teams );
|
||||
while ( i < teams.size )
|
||||
{
|
||||
team = _a194[ _k194 ];
|
||||
if ( team == skip_team )
|
||||
if ( teams[ i ] == skip_team )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
else
|
||||
if ( level.zone.gameobject.numtouching[ teams[ i ] ] )
|
||||
{
|
||||
if ( level.zone.gameobject.numtouching[ team ] )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
_k194 = getNextArrayKey( _a194, _k194 );
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
is_hill_contested( skip_team )
|
||||
is_hill_contested( skip_team ) //checked matches cerberus output
|
||||
{
|
||||
if ( any_other_team_touching( skip_team ) )
|
||||
{
|
||||
@ -201,7 +190,7 @@ is_hill_contested( skip_team )
|
||||
return 0;
|
||||
}
|
||||
|
||||
bot_hill_grenade()
|
||||
bot_hill_grenade() //checked changed to match cerberus output
|
||||
{
|
||||
enemies = bot_get_enemies();
|
||||
if ( !enemies.size )
|
||||
@ -264,16 +253,13 @@ bot_hill_grenade()
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
else if ( !self maps/mp/bots/_bot_combat::bot_combat_throw_lethal( origin ) )
|
||||
{
|
||||
if ( !self maps/mp/bots/_bot_combat::bot_combat_throw_lethal( origin ) )
|
||||
{
|
||||
self maps/mp/bots/_bot_combat::bot_combat_throw_tactical( origin );
|
||||
}
|
||||
self maps/mp/bots/_bot_combat::bot_combat_throw_tactical( origin );
|
||||
}
|
||||
}
|
||||
|
||||
bot_hill_tactical_insertion()
|
||||
bot_hill_tactical_insertion() //checked matches cerberus output
|
||||
{
|
||||
if ( !self hasweapon( "tactical_insertion_mp" ) )
|
||||
{
|
||||
@ -298,11 +284,15 @@ bot_hill_tactical_insertion()
|
||||
}
|
||||
}
|
||||
|
||||
hill_nearest_node()
|
||||
hill_nearest_node() //checked matches cerberus output
|
||||
{
|
||||
nodes = getnodesinradiussorted( level.zone.gameobject.curorigin, 256, 0 );
|
||||
/*
|
||||
/#
|
||||
assert( nodes.size );
|
||||
#/
|
||||
*/
|
||||
return nodes[ 0 ];
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -1,25 +1,25 @@
|
||||
//changed includes to match cerberus output
|
||||
#include maps/mp/gametypes/_globallogic_utils;
|
||||
#include maps/mp/bots/_bot_combat;
|
||||
#include maps/mp/bots/_bot;
|
||||
#include maps/mp/gametypes/_gameobjects;
|
||||
#include maps/mp/_utility;
|
||||
#include common_scripts/utility;
|
||||
|
||||
bot_sd_think()
|
||||
bot_sd_think() //checked changed to match cerberus output
|
||||
{
|
||||
_a8 = level.bombzones;
|
||||
_k8 = getFirstArrayKey( _a8 );
|
||||
while ( isDefined( _k8 ) )
|
||||
foreach ( zone in level.bombzones )
|
||||
{
|
||||
zone = _a8[ _k8 ];
|
||||
if ( !isDefined( zone.nearest_node ) )
|
||||
{
|
||||
nodes = getnodesinradiussorted( zone.trigger.origin, 256, 0 );
|
||||
/*
|
||||
/#
|
||||
assert( nodes.size );
|
||||
#/
|
||||
*/
|
||||
zone.nearest_node = nodes[ 0 ];
|
||||
}
|
||||
_k8 = getNextArrayKey( _a8, _k8 );
|
||||
}
|
||||
zone = sd_get_planted_zone();
|
||||
if ( isDefined( zone ) )
|
||||
@ -41,7 +41,7 @@ bot_sd_think()
|
||||
}
|
||||
}
|
||||
|
||||
bot_sd_attacker()
|
||||
bot_sd_attacker() //checked changed to match cerberus output
|
||||
{
|
||||
level endon( "game_ended" );
|
||||
if ( !level.multibomb && !isDefined( level.sdbomb.carrier ) && !level.bombplanted )
|
||||
@ -73,97 +73,87 @@ bot_sd_attacker()
|
||||
if ( distancesquared( self.origin, goal ) < 2304 )
|
||||
{
|
||||
self setstance( "prone" );
|
||||
wait 0,5;
|
||||
wait 0.5;
|
||||
self pressusebutton( level.planttime + 1 );
|
||||
wait 0,5;
|
||||
wait 0.5;
|
||||
if ( is_true( self.isplanting ) )
|
||||
{
|
||||
wait ( level.planttime + 1 );
|
||||
}
|
||||
self pressusebutton( 0 );
|
||||
self setstance( "crouch" );
|
||||
wait 0,25;
|
||||
wait 0.25;
|
||||
self cancelgoal( "sd_plant" );
|
||||
self setstance( "stand" );
|
||||
}
|
||||
return;
|
||||
}
|
||||
else
|
||||
else if ( getTime() > self.bot[ "patrol_update" ] )
|
||||
{
|
||||
if ( getTime() > self.bot[ "patrol_update" ] )
|
||||
frac = sd_get_time_frac();
|
||||
if ( randomint( 100 ) < ( frac * 100 ) || frac > 0.85 )
|
||||
{
|
||||
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" );
|
||||
zone = sd_get_closest_bomb();
|
||||
goal = sd_get_bomb_goal( zone.visuals[ 0 ] );
|
||||
if ( isDefined( goal ) )
|
||||
{
|
||||
nodes = getnodesinradiussorted( goal, 256, 0 );
|
||||
if ( isDefined( nodes ) && nodes.size > 0 && !isDefined( self getgoal( "sd_protect_carrier" ) ) )
|
||||
if ( frac > 0.85 )
|
||||
{
|
||||
self addgoal( nodes[ randomint( nodes.size ) ], 24, 3, "sd_protect_carrier" );
|
||||
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" );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bot_sd_defender( zone, isplanted )
|
||||
bot_sd_defender( zone, isplanted ) //checked partially changed to match cerberus output did not use foreach see github for more info
|
||||
{
|
||||
bot_sd_grenade();
|
||||
while ( isDefined( isplanted ) && isplanted && self hasgoal( "sd_defend" ) )
|
||||
if ( isDefined( isplanted ) && isplanted && self hasgoal( "sd_defend" ) )
|
||||
{
|
||||
goal = self getgoal( "sd_defend" );
|
||||
planted = sd_get_planted_zone();
|
||||
_a159 = level.bombzones;
|
||||
_k159 = getFirstArrayKey( _a159 );
|
||||
while ( isDefined( _k159 ) )
|
||||
foreach ( zone in level.bombzones )
|
||||
{
|
||||
zone = _a159[ _k159 ];
|
||||
if ( planted != zone && distance2d( goal, zone.nearest_node.origin ) < distance2d( goal, planted.nearest_node.origin ) )
|
||||
{
|
||||
self cancelgoal( "sd_defend" );
|
||||
}
|
||||
_k159 = getNextArrayKey( _a159, _k159 );
|
||||
}
|
||||
}
|
||||
if ( self atgoal( "sd_defend" ) || self bot_need_to_defuse() )
|
||||
else if ( self atgoal( "sd_defend" ) || self bot_need_to_defuse() )
|
||||
{
|
||||
bot_sd_defender_think( zone );
|
||||
if ( self hasgoal( "sd_defend" ) )
|
||||
@ -194,42 +184,45 @@ bot_sd_defender( zone, isplanted )
|
||||
nodes = getvisiblenodes( zone.nearest_node );
|
||||
best = undefined;
|
||||
highest = -100;
|
||||
_a208 = nodes;
|
||||
_k208 = getFirstArrayKey( _a208 );
|
||||
while ( isDefined( _k208 ) )
|
||||
i = 0;
|
||||
while ( i < nodes.size )
|
||||
{
|
||||
node = _a208[ _k208 ];
|
||||
if ( node.type == "BAD NODE" )
|
||||
if ( node[ i ].type == "BAD NODE" )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
else if ( !canclaimnode( node, self.team ) )
|
||||
if ( !canclaimnode( node[ i ], self.team ) )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
else if ( distancesquared( node.origin, self.origin ) < 65536 )
|
||||
if ( distancesquared( node[ i ].origin, self.origin ) < 65536 )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
else if ( self maps/mp/bots/_bot::bot_friend_goal_in_radius( "sd_defend", node.origin, 256 ) > 0 )
|
||||
if ( self maps/mp/bots/_bot::bot_friend_goal_in_radius( "sd_defend", node[ i ].origin, 256 ) > 0 )
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
height = node[ i ].origin[ 2 ] - zone.nearest_node.origin[ 2 ];
|
||||
if ( isDefined( isplanted ) && isplanted )
|
||||
{
|
||||
dist = distance2d( node[ i ].origin, zone.nearest_node.origin );
|
||||
score = ( 10000 - dist ) + height;
|
||||
}
|
||||
else
|
||||
{
|
||||
height = node.origin[ 2 ] - zone.nearest_node.origin[ 2 ];
|
||||
if ( isDefined( isplanted ) && isplanted )
|
||||
{
|
||||
dist = distance2d( node.origin, zone.nearest_node.origin );
|
||||
score = ( 10000 - dist ) + height;
|
||||
}
|
||||
else
|
||||
{
|
||||
score = height;
|
||||
}
|
||||
if ( score > highest )
|
||||
{
|
||||
highest = score;
|
||||
best = node;
|
||||
}
|
||||
score = height;
|
||||
}
|
||||
_k208 = getNextArrayKey( _a208, _k208 );
|
||||
if ( score > highest )
|
||||
{
|
||||
highest = score;
|
||||
best = node;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
if ( !isDefined( best ) )
|
||||
{
|
||||
@ -238,7 +231,7 @@ bot_sd_defender( zone, isplanted )
|
||||
self addgoal( best, 24, 3, "sd_defend" );
|
||||
}
|
||||
|
||||
bot_get_look_at()
|
||||
bot_get_look_at() //checked matches cebrerus output
|
||||
{
|
||||
enemy = self maps/mp/bots/_bot::bot_get_closest_enemy( self.origin, 1 );
|
||||
if ( isDefined( enemy ) )
|
||||
@ -273,7 +266,7 @@ bot_get_look_at()
|
||||
return origin;
|
||||
}
|
||||
|
||||
bot_sd_defender_think( zone )
|
||||
bot_sd_defender_think( zone ) //checked matches cerberus output
|
||||
{
|
||||
if ( self bot_need_to_defuse() )
|
||||
{
|
||||
@ -286,16 +279,16 @@ bot_sd_defender_think( zone )
|
||||
if ( isDefined( goal ) && distancesquared( self.origin, goal ) < 2304 )
|
||||
{
|
||||
self setstance( "prone" );
|
||||
wait 0,5;
|
||||
wait 0.5;
|
||||
self pressusebutton( level.defusetime + 1 );
|
||||
wait 0,5;
|
||||
wait 0.5;
|
||||
if ( is_true( self.isdefusing ) )
|
||||
{
|
||||
wait ( level.defusetime + 1 );
|
||||
}
|
||||
self pressusebutton( 0 );
|
||||
self setstance( "crouch" );
|
||||
wait 0,25;
|
||||
wait 0.25;
|
||||
self cancelgoal( "sd_defuse" );
|
||||
self setstance( "stand" );
|
||||
return;
|
||||
@ -347,15 +340,16 @@ bot_sd_defender_think( zone )
|
||||
}
|
||||
}
|
||||
|
||||
bot_need_to_defuse()
|
||||
bot_need_to_defuse() //checked changed at own discretion
|
||||
{
|
||||
if ( level.bombplanted )
|
||||
if ( level.bombplanted && self.team == game[ "defenders" ] )
|
||||
{
|
||||
return self.team == game[ "defenders" ];
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
sd_get_bomb_goal( ent )
|
||||
sd_get_bomb_goal( ent ) //checked changed to match cerberus output
|
||||
{
|
||||
goals = [];
|
||||
dir = anglesToForward( ent.angles );
|
||||
@ -367,21 +361,17 @@ sd_get_bomb_goal( ent )
|
||||
goals[ 2 ] = ent.origin + dir;
|
||||
goals[ 3 ] = ent.origin - dir;
|
||||
goals = array_randomize( goals );
|
||||
_a419 = goals;
|
||||
_k419 = getFirstArrayKey( _a419 );
|
||||
while ( isDefined( _k419 ) )
|
||||
foreach ( goal in goals )
|
||||
{
|
||||
goal = _a419[ _k419 ];
|
||||
if ( findpath( self.origin, goal, 0 ) )
|
||||
{
|
||||
return goal;
|
||||
}
|
||||
_k419 = getNextArrayKey( _a419, _k419 );
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
sd_get_time_frac()
|
||||
sd_get_time_frac() //checked matches cerberus output
|
||||
{
|
||||
remaining = maps/mp/gametypes/_globallogic_utils::gettimeremaining();
|
||||
end = ( level.timelimit * 60 ) * 1000;
|
||||
@ -393,54 +383,43 @@ sd_get_time_frac()
|
||||
return 1 - ( remaining / end );
|
||||
}
|
||||
|
||||
sd_get_closest_bomb()
|
||||
sd_get_closest_bomb() //checked partially changed to match cerberus output did not use continue see github for more info
|
||||
{
|
||||
best = undefined;
|
||||
distsq = 9999999;
|
||||
_a450 = level.bombzones;
|
||||
_k450 = getFirstArrayKey( _a450 );
|
||||
while ( isDefined( _k450 ) )
|
||||
foreach ( zone in level.bombzones )
|
||||
{
|
||||
zone = _a450[ _k450 ];
|
||||
d = distancesquared( self.origin, zone.curorigin );
|
||||
if ( !isDefined( best ) )
|
||||
{
|
||||
best = zone;
|
||||
distsq = d;
|
||||
}
|
||||
else
|
||||
else if ( d < distsq )
|
||||
{
|
||||
if ( d < distsq )
|
||||
{
|
||||
best = zone;
|
||||
distsq = d;
|
||||
}
|
||||
best = zone;
|
||||
distsq = d;
|
||||
}
|
||||
_k450 = getNextArrayKey( _a450, _k450 );
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
sd_get_planted_zone()
|
||||
sd_get_planted_zone() //checked changed to match cerberus output
|
||||
{
|
||||
while ( level.bombplanted )
|
||||
if ( level.bombplanted )
|
||||
{
|
||||
_a475 = level.bombzones;
|
||||
_k475 = getFirstArrayKey( _a475 );
|
||||
while ( isDefined( _k475 ) )
|
||||
foreach ( zone in level.bombzones )
|
||||
{
|
||||
zone = _a475[ _k475 ];
|
||||
if ( zone.interactteam == "none" )
|
||||
{
|
||||
return zone;
|
||||
}
|
||||
_k475 = getNextArrayKey( _a475, _k475 );
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
bot_sd_grenade()
|
||||
bot_sd_grenade() //checked changed to match cerberus output
|
||||
{
|
||||
enemies = bot_get_enemies();
|
||||
if ( !enemies.size )
|
||||
@ -448,11 +427,8 @@ bot_sd_grenade()
|
||||
return;
|
||||
}
|
||||
zone = sd_get_closest_bomb();
|
||||
_a498 = enemies;
|
||||
_k498 = getFirstArrayKey( _a498 );
|
||||
while ( isDefined( _k498 ) )
|
||||
foreach ( enemy in enemies )
|
||||
{
|
||||
enemy = _a498[ _k498 ];
|
||||
if ( distancesquared( enemy.origin, zone.nearest_node.origin ) < 147456 )
|
||||
{
|
||||
if ( !self maps/mp/bots/_bot_combat::bot_combat_throw_lethal( enemy.origin ) )
|
||||
@ -461,6 +437,6 @@ bot_sd_grenade()
|
||||
}
|
||||
return;
|
||||
}
|
||||
_k498 = getNextArrayKey( _a498, _k498 );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user