mirror of
https://github.com/InfinityLoader/IL-GSC.git
synced 2025-06-07 17:17:50 -05:00
502 lines
8.9 KiB
Plaintext
502 lines
8.9 KiB
Plaintext
/*******************************************************************
|
|
* Decompiled By: Bog
|
|
* Decompiled File: maps\mp\bots\_bot_dom.gsc
|
|
* Game: Call of Duty: Black Ops 2
|
|
* Platform: PC
|
|
* Function Count: 19
|
|
* Decompile Time: 7 ms
|
|
* Timestamp: 10/28/2023 12:10:26 AM
|
|
*******************************************************************/
|
|
|
|
#include common_scripts/utility;
|
|
#include maps/mp/_utility;
|
|
#include maps/mp/bots/_bot;
|
|
#include maps/mp/bots/_bot_combat;
|
|
#include maps/mp/gametypes/dom;
|
|
|
|
//Function Number: 1
|
|
bot_dom_think()
|
|
{
|
|
time = GetTime();
|
|
if(time < self.bot.update_objective)
|
|
{
|
|
return;
|
|
}
|
|
|
|
self.bot.update_objective = time + randomintrange(500,1500);
|
|
if(self bot_is_capturing_flag())
|
|
{
|
|
flag = self dom_get_closest_flag();
|
|
self bot_capture_flag(flag);
|
|
return;
|
|
}
|
|
|
|
flag = self dom_get_closest_flag();
|
|
if(flag getflagteam() != self.team && distance2dsquared(self.origin,flag.origin) < 147456 && !bot_has_flag_goal(flag))
|
|
{
|
|
self bot_move_to_flag(flag);
|
|
return;
|
|
}
|
|
|
|
flag = dom_get_weighted_flag("neutral");
|
|
if(!(IsDefined(flag)))
|
|
{
|
|
flag = dom_get_best_flag(self.team);
|
|
}
|
|
|
|
if(dom_has_two_flags(self.team))
|
|
{
|
|
flag = dom_get_best_flag(self.team);
|
|
}
|
|
|
|
if(!(IsDefined(flag)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!bot_has_flag_goal(flag) && !self bot_goal_is_enemy_flag())
|
|
{
|
|
self bot_move_to_flag(flag);
|
|
}
|
|
else
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Function Number: 2
|
|
bot_move_to_flag(flag)
|
|
{
|
|
if(level.script == "mp_frostbite")
|
|
{
|
|
nodes = getnodesinradius(flag.origin,flag.radius,0,32);
|
|
}
|
|
else
|
|
{
|
|
nodes = getnodesinradius(flag.origin,flag.radius,0);
|
|
}
|
|
|
|
/#
|
|
assert(nodes.size);
|
|
#/
|
|
node = random(nodes);
|
|
self addgoal(node,24,3,"dom_flag");
|
|
}
|
|
|
|
//Function Number: 3
|
|
bot_is_capturing_flag()
|
|
{
|
|
return self atgoal("dom_flag");
|
|
}
|
|
|
|
//Function Number: 4
|
|
bot_has_flag_goal(flag)
|
|
{
|
|
origin = self getgoal("dom_flag");
|
|
if(IsDefined(origin))
|
|
{
|
|
if(distancesquared(flag.origin,origin) < flag.radius * flag.radius)
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Function Number: 5
|
|
bot_has_no_goal()
|
|
{
|
|
origin = self getgoal("dom_flag");
|
|
if(IsDefined(origin))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//Function Number: 6
|
|
bot_goal_is_enemy_flag()
|
|
{
|
|
origin = self getgoal("dom_flag");
|
|
if(IsDefined(origin))
|
|
{
|
|
foreach(flag in level.flags)
|
|
{
|
|
if(distancesquared(flag.origin,origin) < flag.radius * flag.radius)
|
|
{
|
|
if(flag getflagteam() != self.team || dom_is_flag_contested(flag))
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//Function Number: 7
|
|
bot_flag_grenade(flag)
|
|
{
|
|
if(flag getflagteam() != self.team)
|
|
{
|
|
if(bot_tactical_insertion(flag))
|
|
{
|
|
return;
|
|
}
|
|
|
|
self maps/mp/bots/_bot_combat::bot_combat_throw_smoke(flag.origin);
|
|
}
|
|
|
|
if(!(dom_is_flag_contested(flag)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!(self maps/mp/bots/_bot_combat::bot_combat_throw_lethal(flag.origin)))
|
|
{
|
|
if(!(self maps/mp/bots/_bot_combat::bot_combat_throw_tactical(flag.origin)))
|
|
{
|
|
self maps/mp/bots/_bot_combat::bot_combat_throw_proximity(flag.origin);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Function Number: 8
|
|
bot_get_look_at(flag)
|
|
{
|
|
enemy = self maps/mp/bots/_bot::bot_get_closest_enemy(self.origin,0);
|
|
if(IsDefined(enemy))
|
|
{
|
|
node = getvisiblenode(self.origin,enemy.origin);
|
|
if(IsDefined(node) && distancesquared(self.origin,node.origin) > 16384)
|
|
{
|
|
return node.origin;
|
|
}
|
|
}
|
|
|
|
spawn = random(level.spawn_all);
|
|
node = getvisiblenode(self.origin,spawn.origin);
|
|
if(IsDefined(node) && distancesquared(self.origin,node.origin) > 16384)
|
|
{
|
|
return node.origin;
|
|
}
|
|
|
|
return flag.origin;
|
|
}
|
|
|
|
//Function Number: 9
|
|
bot_capture_flag(flag)
|
|
{
|
|
time = GetTime();
|
|
if(flag getflagteam() != self.team)
|
|
{
|
|
if(self getstance() == "prone")
|
|
{
|
|
self addgoal(self.origin,24,4,"dom_flag");
|
|
}
|
|
else
|
|
{
|
|
self addgoal(self.origin,24,3,"dom_flag");
|
|
}
|
|
|
|
if(time > self.bot.update_lookat)
|
|
{
|
|
origin = self bot_get_look_at(flag);
|
|
z = 20;
|
|
if(distancesquared(origin,self.origin) > 262144)
|
|
{
|
|
z = randomintrange(16,60);
|
|
}
|
|
|
|
self lookat(origin + (0,0,z));
|
|
self.bot.update_lookat = time + randomintrange(1500,3000);
|
|
if(distancesquared(origin,self.origin) > 65536)
|
|
{
|
|
dir = vectornormalize(self.origin - origin);
|
|
dir = VectorScale(dir);
|
|
origin = origin + dir;
|
|
}
|
|
|
|
self maps/mp/bots/_bot_combat::bot_combat_throw_proximity(origin);
|
|
self maps/mp/bots/_bot_combat::bot_combat_toss_frag(self.origin);
|
|
self maps/mp/bots/_bot_combat::bot_combat_toss_flash(self.origin);
|
|
if(!(dom_is_game_start()))
|
|
{
|
|
weapon = self getcurrentweapon();
|
|
if(weapon == "riotshield_mp" || weapon == "minigun_mp")
|
|
{
|
|
if(cointoss())
|
|
{
|
|
self addgoal(self.origin,24,4,"dom_flag");
|
|
self setstance("crouch");
|
|
}
|
|
}
|
|
else 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 = self.bot.update_lookat + 5000;
|
|
}
|
|
}
|
|
}
|
|
else if(!(dom_is_game_start()))
|
|
{
|
|
if(self getstance() == "stand")
|
|
{
|
|
wait(randomfloatrange(0.5,1));
|
|
self setstance("crouch");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
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);
|
|
self setstance("stand");
|
|
wait(0.25);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Function Number: 10
|
|
dom_is_game_start()
|
|
{
|
|
/#
|
|
assert(IsDefined(level.flags));
|
|
#/
|
|
foreach(flag in level.flags)
|
|
{
|
|
if(flag getflagteam() != "neutral")
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
//Function Number: 11
|
|
dom_get_closest_flag()
|
|
{
|
|
flags = arraysort(level.flags,self.origin);
|
|
return flags[0];
|
|
}
|
|
|
|
//Function Number: 12
|
|
dom_get_weighted_flag(owner)
|
|
{
|
|
/#
|
|
assert(IsDefined(level.flags));
|
|
#/
|
|
best = undefined;
|
|
distsq = 9999999;
|
|
foreach(flag in level.flags)
|
|
{
|
|
if(IsDefined(owner) && flag getflagteam() != owner)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
d = distancesquared(self.origin,flag.origin);
|
|
if(distsq == 9999999 || (d < distsq && randomint(100) < 70) || randomint(100) > 70)
|
|
{
|
|
best = flag;
|
|
distsq = d;
|
|
}
|
|
}
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
//Function Number: 13
|
|
dom_get_weighted_enemy_flag(team)
|
|
{
|
|
/#
|
|
assert(IsDefined(level.flags));
|
|
#/
|
|
best = undefined;
|
|
distsq = 9999999;
|
|
foreach(flag in level.flags)
|
|
{
|
|
if(flag getflagteam() == team)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
d = distancesquared(self.origin,flag.origin);
|
|
if(distsq == 9999999 || (d < distsq && randomint(100) < 80) || randomint(100) > 80)
|
|
{
|
|
best = flag;
|
|
distsq = d;
|
|
}
|
|
}
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
//Function Number: 14
|
|
dom_is_flag_contested(flag)
|
|
{
|
|
enemy = self maps/mp/bots/_bot::bot_get_closest_enemy(flag.origin,0);
|
|
return IsDefined(enemy) && distancesquared(enemy.origin,flag.origin) < 147456;
|
|
}
|
|
|
|
//Function Number: 15
|
|
dom_has_two_flags(team)
|
|
{
|
|
count = 0;
|
|
foreach(flag in level.flags)
|
|
{
|
|
if(dom_is_flag_contested(flag))
|
|
{
|
|
}
|
|
else if(flag getflagteam() == team)
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count >= 2;
|
|
}
|
|
|
|
//Function Number: 16
|
|
dom_get_weighted_contested_flag(team)
|
|
{
|
|
/#
|
|
assert(IsDefined(level.flags));
|
|
#/
|
|
best = undefined;
|
|
distsq = 9999999;
|
|
foreach(flag in level.flags)
|
|
{
|
|
if(!(dom_is_flag_contested(flag)))
|
|
{
|
|
}
|
|
else
|
|
{
|
|
d = distancesquared(self.origin,flag.origin);
|
|
if(distsq == 9999999 || (d < distsq && randomint(100) < 80) || randomint(100) > 80)
|
|
{
|
|
best = flag;
|
|
distsq = d;
|
|
}
|
|
}
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
//Function Number: 17
|
|
dom_get_random_flag(owner)
|
|
{
|
|
/#
|
|
assert(IsDefined(level.flags));
|
|
#/
|
|
flagindex = randomintrange(0,level.flags.size);
|
|
if(!(IsDefined(owner)))
|
|
{
|
|
return level.flags[flagindex];
|
|
}
|
|
|
|
for(i = 0;i < level.flags.size;i++)
|
|
{
|
|
if(level.flags[flagindex] getflagteam() == owner)
|
|
{
|
|
return level.flags[flagindex];
|
|
}
|
|
|
|
flagindex = flagindex + 1 % level.flags.size;
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
//Function Number: 18
|
|
dom_get_best_flag(team)
|
|
{
|
|
flag1 = dom_get_weighted_enemy_flag(team);
|
|
flag2 = dom_get_weighted_contested_flag(team);
|
|
if(!(IsDefined(flag1)))
|
|
{
|
|
return flag2;
|
|
}
|
|
|
|
if(!(IsDefined(flag2)))
|
|
{
|
|
return flag1;
|
|
}
|
|
|
|
offchance = randomint(100) > 80;
|
|
if(distancesquared(self.origin,flag1.origin) < distancesquared(self.origin,flag2.origin))
|
|
{
|
|
if(!(offchance))
|
|
{
|
|
return flag1;
|
|
}
|
|
else
|
|
{
|
|
return flag2;
|
|
}
|
|
}
|
|
|
|
if(!(offchance))
|
|
{
|
|
return flag2;
|
|
}
|
|
else
|
|
{
|
|
return flag1;
|
|
}
|
|
}
|
|
|
|
//Function Number: 19
|
|
bot_tactical_insertion(flag)
|
|
{
|
|
if(self getweaponammostock("tactical_insertion_mp") <= 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
dist = self getlookaheaddist();
|
|
dir = self getlookaheaddir();
|
|
if(!IsDefined(dist) || !IsDefined(dir))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
node = bot_nearest_node(flag.origin);
|
|
mine = bot_nearest_node(self.origin);
|
|
if(IsDefined(mine) && !nodesvisible(mine,node))
|
|
{
|
|
origin = dist + VectorScale(dir);
|
|
next = bot_nearest_node(origin);
|
|
if(next isdangerous(self.team))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if(IsDefined(next) && nodesvisible(next,node))
|
|
{
|
|
return bot_combat_tactical_insertion(self.origin);
|
|
}
|
|
}
|
|
} |