qcsrc/server/steerlib.qc

   1 #include "steerlib.qh"
   2 #if defined(CSQC)
   3 #elif defined(MENUQC)
   4 #elif defined(SVQC)
   5     #include "pathlib/utility.qh"
   6 #endif
   7
   8 /**
   9     Uniform pull towards a point
  10 **/
  11 #define steerlib_pull(ent,point) normalize(point - (ent).origin)
  12 /*vector steerlib_pull(entity this, vector point)
  13 {
  14     return normalize(point - this.origin);
  15 }*/
  16
  17 /**
  18     Uniform push from a point
  19 **/
  20 #define steerlib_push(ent,point) normalize((ent).origin - point)
  21 /*
  22 vector steerlib_push(entity this, vector point)
  23 {
  24     return normalize(this.origin - point);
  25 }
  26 */
  27 /**
  28     Pull toward a point, The further away, the stronger the pull.
  29 **/
  30 vector steerlib_arrive(entity this, vector point, float maximal_distance)
  31 {
  32     float distance = bound(0.001, vlen(this.origin - point), maximal_distance);
  33     vector direction = normalize(point - this.origin);
  34     return  direction * (distance / maximal_distance);
  35 }
  36
  37 /**
  38     Pull toward a point increasing the pull the closer we get
  39 **/
  40 vector steerlib_attract(entity this, vector point, float maximal_distance)
  41 {
  42     float distance = bound(0.001, vlen(this.origin - point), maximal_distance);
  43     vector direction = normalize(point - this.origin);
  44
  45     return  direction * (1 - (distance / maximal_distance));
  46 }
  47
  48 vector steerlib_attract2(entity this, vector point, float min_influense, float max_distance, float max_influense)
  49 {
  50     float distance = bound(0.00001, vlen(this.origin - point), max_distance);
  51     vector direction = normalize(point - this.origin);
  52
  53     float influense = 1 - (distance / max_distance);
  54     influense = min_influense + (influense * (max_influense - min_influense));
  55
  56     return direction * influense;
  57 }
  58
  59 /*
  60 vector steerlib_attract2(vector point, float maximal_distance,float min_influense,float max_influense,float distance)
  61 {
  62     //float distance;
  63     vector current_direction;
  64     vector target_direction;
  65     float i_target,i_current;
  66
  67     if(!distance)
  68         distance = vlen(this.origin - point);
  69
  70     distance = bound(0.001,distance,maximal_distance);
  71
  72     target_direction = normalize(point - this.origin);
  73     current_direction = normalize(this.velocity);
  74
  75     i_target = bound(min_influense,(1-(distance / maximal_distance)),max_influense);
  76     i_current = 1 - i_target;
  77
  78     // i_target = bound(min_influense,(1-(distance / maximal_distance)),max_influense);
  79
  80     string s;
  81     s = ftos(i_target);
  82     bprint("IT: ",s,"\n");
  83     s = ftos(i_current);
  84     bprint("IC  : ",s,"\n");
  85
  86     return  normalize((target_direction * i_target) + (current_direction * i_current));
  87 }
  88 */
  89 /**
  90     Move away from a point.
  91 **/
  92 vector steerlib_repel(entity this, vector point, float maximal_distance)
  93 {
  94     float distance = bound(0.001, vlen(this.origin - point), maximal_distance);
  95     vector direction = normalize(this.origin - point);
  96
  97     return  direction * (1 - (distance / maximal_distance));
  98 }
  99
 100 /**
 101     Try to keep at ideal_distance away from point
 102 **/
 103 vector steerlib_standoff(entity this, vector point, float ideal_distance)
 104 {
 105     vector direction;
 106     float distance = vlen(this.origin - point);
 107
 108     if(distance < ideal_distance)
 109     {
 110         direction = normalize(this.origin - point);
 111         return direction * (distance / ideal_distance);
 112     }
 113
 114     direction = normalize(point - this.origin);
 115     return direction * (ideal_distance / distance);
 116
 117 }
 118
 119 /**
 120     A random heading in a forward semicircle
 121
 122     usage:
 123     this.target = steerlib_wander(256, 32, this.target)
 124
 125     where range is the circle radius and threshold is how close we need to be to pick a new heading.
 126     Assumes v_forward is set by makevectors
 127 **/
 128 vector steerlib_wander(entity this, float range, float threshold, vector oldpoint)
 129 {
 130     vector wander_point = v_forward - oldpoint;
 131
 132     if (vdist(wander_point, >, threshold))
 133         return oldpoint;
 134
 135     range = bound(0, range, 1);
 136
 137     wander_point = this.origin + v_forward * 128;
 138     wander_point = wander_point + randomvec() * (range * 128) - randomvec() * (range * 128);
 139
 140     return normalize(wander_point - this.origin);
 141 }
 142
 143 /**
 144     Dodge a point NOTE: doesn't work well
 145 **/
 146 vector steerlib_dodge(entity this, vector point, vector dodge_dir, float min_distance)
 147 {
 148     float distance = max(vlen(this.origin - point), min_distance);
 149     if (min_distance < distance)
 150         return '0 0 0';
 151
 152     return dodge_dir * (min_distance / distance);
 153 }
 154
 155 /**
 156     flocking by .flock_id
 157     Group will move towards the unified direction while keeping close to eachother.
 158 **/
 159 .float flock_id;
 160 vector steerlib_flock(entity this, float _radius, float standoff, float separation_force, float flock_force)
 161 {
 162     vector push = '0 0 0', pull = '0 0 0';
 163     int ccount = 0;
 164
 165     entity flock_member = findradius(this.origin, _radius);
 166     while(flock_member)
 167     {
 168         if(flock_member != this)
 169         if(flock_member.flock_id == this.flock_id)
 170         {
 171             ++ccount;
 172             push = push + (steerlib_repel(this, flock_member.origin,standoff) * separation_force);
 173             pull = pull + (steerlib_arrive(this, flock_member.origin + flock_member.velocity, _radius) * flock_force);
 174         }
 175         flock_member = flock_member.chain;
 176     }
 177     return push + (pull* (1 / ccount));
 178 }
 179
 180 /**
 181     flocking by .flock_id
 182     Group will move towards the unified direction while keeping close to eachother.
 183     xy only version (for ground movers).
 184 **/
 185 vector steerlib_flock2d(entity this, float _radius, float standoff, float separation_force, float flock_force)
 186 {
 187     vector push = '0 0 0', pull = '0 0 0';
 188     int ccount = 0;
 189
 190     entity flock_member = findradius(this.origin,_radius);
 191     while(flock_member)
 192     {
 193         if(flock_member != this)
 194         if(flock_member.flock_id == this.flock_id)
 195         {
 196             ++ccount;
 197             push = push + (steerlib_repel(this, flock_member.origin, standoff) * separation_force);
 198             pull = pull + (steerlib_arrive(this, flock_member.origin + flock_member.velocity, _radius) * flock_force);
 199         }
 200         flock_member = flock_member.chain;
 201     }
 202
 203     push.z = 0;
 204     pull.z = 0;
 205
 206     return push + (pull * (1 / ccount));
 207 }
 208
 209 /**
 210     All members want to be in the center, and keep away from eachother.
 211     The further from the center the more they want to be there.
 212
 213     This results in a aligned movement (?!) much like flocking.
 214 **/
 215 vector steerlib_swarm(entity this, float _radius, float standoff, float separation_force, float swarm_force)
 216 {
 217     vector force = '0 0 0', center = '0 0 0';
 218     int ccount = 0;
 219
 220     entity swarm_member = findradius(this.origin,_radius);
 221     while(swarm_member)
 222     {
 223         if(swarm_member.flock_id == this.flock_id)
 224         {
 225             ++ccount;
 226             center = center + swarm_member.origin;
 227             force = force + (steerlib_repel(this, swarm_member.origin,standoff) * separation_force);
 228         }
 229         swarm_member = swarm_member.chain;
 230     }
 231
 232     center = center * (1 / ccount);
 233     force = force + (steerlib_arrive(this, center,_radius) * swarm_force);
 234
 235     return force;
 236 }
 237
 238 /**
 239     Steer towards the direction least obstructed.
 240     Run four tracelines in a forward funnel, bias each diretion negative if something is found there.
 241     You need to call makevectors() (or equivalent) before this function to set v_forward and v_right
 242 **/
 243 vector steerlib_traceavoid(entity this, float pitch, float length)
 244 {
 245     vector v_left = v_right * -1;
 246     vector v_down = v_up * -1;
 247
 248     vector vup_left = (v_forward + (v_left * pitch + v_up * pitch)) * length;
 249     traceline(this.origin, this.origin +  vup_left, MOVE_NOMONSTERS, this);
 250     float fup_left = trace_fraction;
 251
 252     //te_lightning1(NULL,this.origin, trace_endpos);
 253
 254     vector vup_right = (v_forward + (v_right * pitch + v_up * pitch)) * length;
 255     traceline(this.origin, this.origin + vup_right, MOVE_NOMONSTERS, this);
 256     float fup_right = trace_fraction;
 257
 258     //te_lightning1(NULL,this.origin, trace_endpos);
 259
 260     vector vdown_left = (v_forward + (v_left * pitch + v_down * pitch)) * length;
 261     traceline(this.origin, this.origin + vdown_left, MOVE_NOMONSTERS, this);
 262     float fdown_left = trace_fraction;
 263
 264     //te_lightning1(NULL,this.origin, trace_endpos);
 265
 266     vector vdown_right = (v_forward + (v_right * pitch + v_down * pitch)) * length;
 267     traceline(this.origin, this.origin + vdown_right, MOVE_NOMONSTERS, this);
 268     float fdown_right = trace_fraction;
 269
 270     //te_lightning1(NULL,this.origin, trace_endpos);
 271     vector upwish    = v_up    * (fup_left   + fup_right);
 272     vector downwish  = v_down  * (fdown_left + fdown_right);
 273     vector leftwish  = v_left  * (fup_left   + fdown_left);
 274     vector rightwish = v_right * (fup_right  + fdown_right);
 275
 276     return (upwish + leftwish + downwish + rightwish) * 0.25;
 277
 278 }
 279
 280 /**
 281     Steer towards the direction least obstructed.
 282     Run tracelines in a forward trident, bias each direction negative if something is found there.
 283     You need to call makevectors() (or equivalent) before this function to set v_forward and v_right
 284 **/
 285 vector steerlib_traceavoid_flat(entity this, float pitch, float length, vector vofs)
 286 {
 287     vector v_left = v_right * -1;
 288
 289     vector vt_front = v_forward * length;
 290     traceline(this.origin + vofs, this.origin + vofs + vt_front,MOVE_NOMONSTERS,this);
 291     float f_front = trace_fraction;
 292
 293     vector vt_left = (v_forward + (v_left * pitch)) * length;
 294     traceline(this.origin + vofs, this.origin + vofs + vt_left,MOVE_NOMONSTERS,this);
 295     float f_left = trace_fraction;
 296
 297     //te_lightning1(NULL,this.origin, trace_endpos);
 298
 299     vector vt_right = (v_forward + (v_right * pitch)) * length;
 300     traceline(this.origin + vofs, this.origin + vofs + vt_right ,MOVE_NOMONSTERS,this);
 301     float f_right = trace_fraction;
 302
 303     //te_lightning1(NULL,this.origin, trace_endpos);
 304
 305     vector leftwish  = v_left    * f_left;
 306     vector rightwish = v_right   * f_right;
 307     vector frontwish = v_forward * f_front;
 308
 309     return normalize(leftwish + rightwish + frontwish);
 310 }
 311
 312 //#define BEAMSTEER_VISUAL
 313 float beamsweep(entity this, vector from, vector dir, float length, float step, float step_up, float step_down)
 314 {
 315     vector u = '0 0 1' * step_up;
 316     vector d = '0 0 1' * step_down;
 317
 318     traceline(from + u, from - d,MOVE_NORMAL,this);
 319     if(trace_fraction == 1.0)
 320         return 0;
 321
 322     if(!location_isok(trace_endpos, false, false))
 323         return 0;
 324
 325     vector a = trace_endpos;
 326     for(int i = 0; i < length; i += step)
 327     {
 328
 329         vector b = a + dir * step;
 330         tracebox(a + u,'-4 -4 -4','4 4 4', b + u,MOVE_NORMAL,this);
 331         if(trace_fraction != 1.0)
 332             return i / length;
 333
 334         traceline(b + u, b - d,MOVE_NORMAL,this);
 335         if(trace_fraction == 1.0)
 336             return i / length;
 337
 338         if(!location_isok(trace_endpos, false, false))
 339             return i / length;
 340 #ifdef BEAMSTEER_VISUAL
 341         te_lightning1(NULL,a+u,b+u);
 342         te_lightning1(NULL,b+u,b-d);
 343 #endif
 344         a = trace_endpos;
 345     }
 346
 347     return 1;
 348 }
 349
 350 vector steerlib_beamsteer(entity this, vector dir, float length, float step, float step_up, float step_down)
 351 {
 352     dir.z *= 0.15;
 353     vector vr = vectoangles(dir);
 354     //vr.x *= -1;
 355
 356     tracebox(this.origin + '0 0 1' * step_up, this.mins, this.maxs, ('0 0 1' * step_up) + this.origin +  (dir * length), MOVE_NOMONSTERS, this);
 357     if(trace_fraction == 1.0)
 358     {
 359         //te_lightning1(this,this.origin,this.origin + (dir * length));
 360         return dir;
 361     }
 362
 363     makevectors(vr);
 364     float bm_forward = beamsweep(this, this.origin, v_forward, length, step, step_up, step_down);
 365
 366     vr = normalize(v_forward + v_right * 0.125);
 367     vector vl = normalize(v_forward - v_right * 0.125);
 368
 369     float bm_right = beamsweep(this, this.origin, vr, length, step, step_up, step_down);
 370     float bm_left  = beamsweep(this, this.origin, vl, length, step, step_up, step_down);
 371
 372     float p = bm_left + bm_right;
 373     if(p == 2)
 374     {
 375         //te_lightning1(this,this.origin + '0 0 32',this.origin + '0 0 32' + vr * length);
 376         //te_lightning1(this.tur_head,this.origin + '0 0 32',this.origin + '0 0 32' + vl * length);
 377
 378         return v_forward;
 379     }
 380
 381     p = 2 - p;
 382
 383     vr = normalize(v_forward + v_right * p);
 384     vl = normalize(v_forward - v_right * p);
 385     bm_right = beamsweep(this, this.origin, vr, length, step, step_up, step_down);
 386     bm_left  = beamsweep(this, this.origin, vl, length, step, step_up, step_down);
 387
 388
 389     if(bm_left + bm_right < 0.15)
 390     {
 391         vr = normalize((v_forward*-1) + v_right * 0.90);
 392         vl = normalize((v_forward*-1) - v_right * 0.90);
 393
 394         bm_right = beamsweep(this, this.origin, vr, length, step, step_up, step_down);
 395         bm_left  = beamsweep(this, this.origin, vl, length, step, step_up, step_down);
 396     }
 397
 398     //te_lightning1(this,this.origin + '0 0 32',this.origin + '0 0 32' + vr * length);
 399     //te_lightning1(this.tur_head,this.origin + '0 0 32',this.origin + '0 0 32' + vl * length);
 400
 401     bm_forward *= bm_forward;
 402     bm_right   *= bm_right;
 403     bm_left    *= bm_left;
 404
 405     vr = vr * bm_right;
 406     vl = vl * bm_left;
 407
 408     return normalize(vr + vl);
 409 }