+entity ka_ball;
// traces multiple trajectories to find one that will impact the target
// 'end' vector is the place it aims for,
// returns TRUE only if it hit targ (don't target non-solid entities)
float findtrajectorywithleading(vector org, vector m1, vector m2, entity targ, float shotspeed, float shotspeedupward, float maxtime, float shotdelay, entity ignore)
{
- local float c, savesolid, shottime;
- local vector dir, end, v;
+ float c, savesolid, shottime;
+ vector dir, end, v, o;
if (shotspeed < 1)
return FALSE; // could cause division by zero if calculated
if (targ.solid < SOLID_BBOX) // SOLID_NOT and SOLID_TRIGGER
setsize(tracetossent, m1, m2);
savesolid = targ.solid;
targ.solid = SOLID_NOT;
- shottime = ((vlen(targ.origin - org) / shotspeed) + shotdelay);
- v = targ.velocity * shottime + targ.origin;
- tracebox(targ.origin, targ.mins, targ.maxs, v, FALSE, targ);
+ o = (targ.absmin + targ.absmax) * 0.5;
+ shottime = ((vlen(o - org) / shotspeed) + shotdelay);
+ v = targ.velocity * shottime + o;
+ tracebox(o, targ.mins, targ.maxs, v, FALSE, targ);
v = trace_endpos;
end = v + (targ.mins + targ.maxs) * 0.5;
if ((vlen(end - org) / shotspeed + 0.2) > maxtime)
// leave a valid one even if it won't reach
findtrajectory_velocity = normalize(end - org) * shotspeed + shotspeedupward * '0 0 1';
return FALSE;
-};
+}
void lag_update()
{
if (self.lag3_time) if (time > self.lag3_time) {self.lag_func(self.lag3_time, self.lag3_float1, self.lag3_float2, self.lag3_entity1, self.lag3_vec1, self.lag3_vec2, self.lag3_vec3, self.lag3_vec4);self.lag3_time = 0;}
if (self.lag4_time) if (time > self.lag4_time) {self.lag_func(self.lag4_time, self.lag4_float1, self.lag4_float2, self.lag4_entity1, self.lag4_vec1, self.lag4_vec2, self.lag4_vec3, self.lag4_vec4);self.lag4_time = 0;}
if (self.lag5_time) if (time > self.lag5_time) {self.lag_func(self.lag5_time, self.lag5_float1, self.lag5_float2, self.lag5_entity1, self.lag5_vec1, self.lag5_vec2, self.lag5_vec3, self.lag5_vec4);self.lag5_time = 0;}
-};
+}
float lag_additem(float t, float f1, float f2, entity e1, vector v1, vector v2, vector v3, vector v4)
{
if (self.lag5_time == 0) {self.lag5_time = t;self.lag5_float1 = f1;self.lag5_float2 = f2;self.lag5_entity1 = e1;self.lag5_vec1 = v1;self.lag5_vec2 = v2;self.lag5_vec3 = v3;self.lag5_vec4 = v4;return TRUE;}
// no room for it (what is the best thing to do here??)
return FALSE;
-};
+}
float bot_shouldattack(entity e)
{
{
if (e == self)
return FALSE;
- if (teams_matter)
+ if (teamplay)
if (e.team != 0)
return FALSE;
}
- if(g_freezetag)
- if(e.freezetag_frozen)
+ if(e.freezetag_frozen)
+ return FALSE;
+
+ // If neither player has ball then don't attack unless the ball is on the
+ // ground.
+ if (g_keepaway)
+ if (!e.ballcarried && !self.ballcarried && ka_ball.owner)
return FALSE;
- if(teams_matter)
+ if(teamplay)
{
if(e.team==0)
return FALSE;
}
else if(bot_ignore_bots)
- if(clienttype(e) == CLIENTTYPE_BOT)
+ if(IS_BOT_CLIENT(e))
return FALSE;
if (!e.takedamage)
return FALSE;
if (e.BUTTON_CHAT)
return FALSE;
- if(g_minstagib)
- if(e.items & IT_STRENGTH)
- return FALSE;
if(e.flags & FL_NOTARGET)
return FALSE;
+
+ checkentity = e;
+ if(MUTATOR_CALLHOOK(BotShouldAttack))
+ return FALSE;
+
return TRUE;
-};
+}
void bot_lagfunc(float t, float f1, float f2, entity e1, vector v1, vector v2, vector v3, vector v4)
{
self.bot_canfire = (random() < 0.95);
else
self.bot_canfire = 1;
-};
+}
float bot_aimdir(vector v, float maxfiredeviation)
{
- local float dist, delta_t, blend;
- local vector desiredang, diffang;
+ float dist, delta_t, blend;
+ vector desiredang, diffang;
//dprint("aim ", self.netname, ": old:", vtos(self.v_angle));
// make sure v_angle is sane first
if (time >= self.bot_badaimtime)
{
self.bot_badaimtime = max(self.bot_badaimtime + 0.3, time);
- self.bot_badaimoffset = randomvec() * bound(0, 5 - 0.5 * (skill+self.bot_offsetskill), 5) * cvar("bot_ai_aimskill_offset");
+ self.bot_badaimoffset = randomvec() * bound(0, 5 - 0.5 * (skill+self.bot_offsetskill), 5) * autocvar_bot_ai_aimskill_offset;
}
desiredang = vectoangles(v) + self.bot_badaimoffset;
//dprint(" desired:", vtos(desiredang));
self.bot_prevaimtime = time;
// Here we will try to anticipate the comming aiming direction
self.bot_1st_order_aimfilter= self.bot_1st_order_aimfilter
- + (diffang * (1 / delta_t) - self.bot_1st_order_aimfilter) * bound(0, cvar("bot_ai_aimskill_order_filter_1st"),1);
+ + (diffang * (1 / delta_t) - self.bot_1st_order_aimfilter) * bound(0, autocvar_bot_ai_aimskill_order_filter_1st,1);
self.bot_2nd_order_aimfilter= self.bot_2nd_order_aimfilter
- + (self.bot_1st_order_aimfilter - self.bot_2nd_order_aimfilter) * bound(0, cvar("bot_ai_aimskill_order_filter_2nd"),1);
+ + (self.bot_1st_order_aimfilter - self.bot_2nd_order_aimfilter) * bound(0, autocvar_bot_ai_aimskill_order_filter_2nd,1);
self.bot_3th_order_aimfilter= self.bot_3th_order_aimfilter
- + (self.bot_2nd_order_aimfilter - self.bot_3th_order_aimfilter) * bound(0, cvar("bot_ai_aimskill_order_filter_3th"),1);
+ + (self.bot_2nd_order_aimfilter - self.bot_3th_order_aimfilter) * bound(0, autocvar_bot_ai_aimskill_order_filter_3th,1);
self.bot_4th_order_aimfilter= self.bot_4th_order_aimfilter
- + (self.bot_3th_order_aimfilter - self.bot_4th_order_aimfilter) * bound(0, cvar("bot_ai_aimskill_order_filter_4th"),1);
+ + (self.bot_3th_order_aimfilter - self.bot_4th_order_aimfilter) * bound(0, autocvar_bot_ai_aimskill_order_filter_4th,1);
self.bot_5th_order_aimfilter= self.bot_5th_order_aimfilter
- + (self.bot_4th_order_aimfilter - self.bot_5th_order_aimfilter) * bound(0, cvar("bot_ai_aimskill_order_filter_5th"),1);
+ + (self.bot_4th_order_aimfilter - self.bot_5th_order_aimfilter) * bound(0, autocvar_bot_ai_aimskill_order_filter_5th,1);
//blend = (bound(0,skill,10)*0.1)*pow(1-bound(0,skill,10)*0.05,2.5)*5.656854249; //Plot formule before changing !
blend = bound(0,skill+self.bot_aimskill,10)*0.1;
desiredang = desiredang + blend *
(
- self.bot_1st_order_aimfilter * cvar("bot_ai_aimskill_order_mix_1st")
- + self.bot_2nd_order_aimfilter * cvar("bot_ai_aimskill_order_mix_2nd")
- + self.bot_3th_order_aimfilter * cvar("bot_ai_aimskill_order_mix_3th")
- + self.bot_4th_order_aimfilter * cvar("bot_ai_aimskill_order_mix_4th")
- + self.bot_5th_order_aimfilter * cvar("bot_ai_aimskill_order_mix_5th")
+ self.bot_1st_order_aimfilter * autocvar_bot_ai_aimskill_order_mix_1st
+ + self.bot_2nd_order_aimfilter * autocvar_bot_ai_aimskill_order_mix_2nd
+ + self.bot_3th_order_aimfilter * autocvar_bot_ai_aimskill_order_mix_3th
+ + self.bot_4th_order_aimfilter * autocvar_bot_ai_aimskill_order_mix_4th
+ + self.bot_5th_order_aimfilter * autocvar_bot_ai_aimskill_order_mix_5th
);
// calculate turn angles
diffang_y = diffang_y - floor(diffang_y / 360) * 360;
if (diffang_y >= 180)
diffang_y = diffang_y - 360;
- desiredang = desiredang + diffang * bound(0,cvar("bot_ai_aimskill_think"),1);
+ desiredang = desiredang + diffang * bound(0,autocvar_bot_ai_aimskill_think,1);
// calculate turn angles
diffang = desiredang - self.v_angle;
//diffang = diffang + randomvec() * (dist * 0.05 * (3.5 - bound(0, skill, 3)));
// turn
- local float r, fixedrate, blendrate;
- fixedrate = cvar("bot_ai_aimskill_fixedrate") / bound(1,dist,1000);
- blendrate = cvar("bot_ai_aimskill_blendrate");
+ float r, fixedrate, blendrate;
+ fixedrate = autocvar_bot_ai_aimskill_fixedrate / bound(1,dist,1000);
+ blendrate = autocvar_bot_ai_aimskill_blendrate;
r = max(fixedrate, blendrate);
//self.v_angle = self.v_angle + diffang * bound(frametime, r * frametime * (2+skill*skill*0.05-random()*0.05*(10-skill)), 1);
self.v_angle = self.v_angle + diffang * bound(delta_t, r * delta_t * (2+pow(skill+self.bot_mouseskill,3)*0.005-random()), 1);
- self.v_angle = self.v_angle * bound(0,cvar("bot_ai_aimskill_mouse"),1) + desiredang * bound(0,(1-cvar("bot_ai_aimskill_mouse")),1);
+ self.v_angle = self.v_angle * bound(0,autocvar_bot_ai_aimskill_mouse,1) + desiredang * bound(0,(1-autocvar_bot_ai_aimskill_mouse),1);
//self.v_angle = self.v_angle + diffang * bound(0, r * frametime * (skill * 0.5 + 2), 1);
//self.v_angle = self.v_angle + diffang * (1/ blendrate);
self.v_angle_z = 0;
//dprint(" diff:", vtos(diffang), "\n");
return self.bot_canfire && (time < self.bot_firetimer);
-};
+}
vector bot_shotlead(vector targorigin, vector targvelocity, float shotspeed, float shotdelay)
{
// Try to add code here that predicts gravity effect here, no clue HOW to though ... well not yet atleast...
return targorigin + targvelocity * (shotdelay + vlen(targorigin - shotorg) / shotspeed);
-};
+}
float bot_aim(float shotspeed, float shotspeedupward, float maxshottime, float applygravity)
{
- local float f, r;
- local vector v;
+ float f, r, hf, distanceratio;
+ vector v;
/*
eprint(self);
dprint("bot_aim(", ftos(shotspeed));
dprint(", ", ftos(applygravity));
dprint(");\n");
*/
+
+ hf = self.dphitcontentsmask;
+ self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;
+
shotspeed *= g_weaponspeedfactor;
shotspeedupward *= g_weaponspeedfactor;
if (!shotspeed)
shotorg = self.origin + self.view_ofs;
shotdir = v_forward;
v = bot_shotlead(self.bot_aimtargorigin, self.bot_aimtargvelocity, shotspeed, self.bot_aimlatency);
- local float distanceratio;
- distanceratio =sqrt(bound(0,skill,10000))*0.3*(vlen(v-shotorg)-100)/cvar("bot_ai_aimskill_firetolerance_distdegrees");
+ distanceratio = sqrt(bound(0,skill,10000))*0.3*(vlen(v-shotorg)-100)/autocvar_bot_ai_aimskill_firetolerance_distdegrees;
distanceratio = bound(0,distanceratio,1);
- r = (cvar("bot_ai_aimskill_firetolerance_maxdegrees")-cvar("bot_ai_aimskill_firetolerance_mindegrees"))
- * (1-distanceratio) + cvar("bot_ai_aimskill_firetolerance_mindegrees");
+ r = (autocvar_bot_ai_aimskill_firetolerance_maxdegrees-autocvar_bot_ai_aimskill_firetolerance_mindegrees)
+ * (1-distanceratio) + autocvar_bot_ai_aimskill_firetolerance_mindegrees;
if (applygravity && self.bot_aimtarg)
{
if (!findtrajectorywithleading(shotorg, '0 0 0', '0 0 0', self.bot_aimtarg, shotspeed, shotspeedupward, maxshottime, 0, self))
+ {
+ self.dphitcontentsmask = hf;
return FALSE;
+ }
+
f = bot_aimdir(findtrajectory_velocity - shotspeedupward * '0 0 1', r);
}
else
{
f = bot_aimdir(v - shotorg, r);
//dprint("AIM: ");dprint(vtos(self.bot_aimtargorigin));dprint(" + ");dprint(vtos(self.bot_aimtargvelocity));dprint(" * ");dprint(ftos(self.bot_aimlatency + vlen(self.bot_aimtargorigin - shotorg) / shotspeed));dprint(" = ");dprint(vtos(v));dprint(" : aimdir = ");dprint(vtos(normalize(v - shotorg)));dprint(" : ");dprint(vtos(shotdir));dprint("\n");
- traceline(shotorg, shotorg + shotdir * 10000, FALSE, self);
- if (trace_ent.takedamage)
- if (trace_fraction < 1)
- if (!bot_shouldattack(trace_ent))
- return FALSE;
+ //traceline(shotorg, shotorg + shotdir * 10000, FALSE, self);
+ //if (trace_ent.takedamage)
+ //if (trace_fraction < 1)
+ //if (!bot_shouldattack(trace_ent))
+ // return FALSE;
traceline(shotorg, self.bot_aimtargorigin, FALSE, self);
if (trace_fraction < 1)
if (trace_ent != self.enemy)
if (!bot_shouldattack(trace_ent))
+ {
+ self.dphitcontentsmask = hf;
return FALSE;
+ }
}
- if (r > maxshottime * shotspeed)
- return FALSE;
- return f;
-};
+
+ //if (r > maxshottime * shotspeed)
+ // return FALSE;
+ self.dphitcontentsmask = hf;
+ return TRUE;
+}
projects / xonotic / xonotic-data.pk3dir.git / blobdiff