Don't #include server files from CSQC
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / steerlib.qc
1 #include "steerlib.qh"
2 #if defined(CSQC)
3 #elif defined(MENUQC)
4 #elif defined(SVQC)
5 #endif
6
7 /**
8     Uniform pull towards a point
9 **/
10 vector steerlib_pull(entity this, vector point)
11 {
12     return normalize(point - this.origin);
13 }
14
15 /**
16     Uniform push from a point
17 **/
18 #define steerlib_push(ent,point) normalize(ent.origin - point)
19 /*
20 vector steerlib_push(entity this, vector point)
21 {
22     return normalize(this.origin - point);
23 }
24 */
25 /**
26     Pull toward a point, The further away, the stronger the pull.
27 **/
28 vector steerlib_arrive(entity this, vector point, float maximal_distance)
29 {
30     float distance;
31     vector direction;
32
33     distance = bound(0.001,vlen(this.origin - point),maximal_distance);
34     direction = normalize(point - this.origin);
35     return  direction * (distance / maximal_distance);
36 }
37
38 /**
39     Pull toward a point increasing the pull the closer we get
40 **/
41 vector steerlib_attract(entity this, vector point, float maximal_distance)
42 {
43     float distance;
44     vector direction;
45
46     distance = bound(0.001,vlen(this.origin - point),maximal_distance);
47     direction = normalize(point - this.origin);
48
49     return  direction * (1-(distance / maximal_distance));
50 }
51
52 vector steerlib_attract2(entity this, vector point, float min_influense,float max_distance,float max_influense)
53 {
54     float distance;
55     vector direction;
56     float influense;
57
58     distance  = bound(0.00001,vlen(this.origin - point),max_distance);
59     direction = normalize(point - this.origin);
60
61     influense = 1 - (distance / max_distance);
62     influense = min_influense + (influense * (max_influense - min_influense));
63
64     return  direction * influense;
65 }
66
67 /*
68 vector steerlib_attract2(vector point, float maximal_distance,float min_influense,float max_influense,float distance)
69 {
70     //float distance;
71     vector current_direction;
72     vector target_direction;
73     float i_target,i_current;
74
75     if(!distance)
76         distance = vlen(this.origin - point);
77
78     distance = bound(0.001,distance,maximal_distance);
79
80     target_direction = normalize(point - this.origin);
81     current_direction = normalize(this.velocity);
82
83     i_target = bound(min_influense,(1-(distance / maximal_distance)),max_influense);
84     i_current = 1 - i_target;
85
86     // i_target = bound(min_influense,(1-(distance / maximal_distance)),max_influense);
87
88     string s;
89     s = ftos(i_target);
90     bprint("IT: ",s,"\n");
91     s = ftos(i_current);
92     bprint("IC  : ",s,"\n");
93
94     return  normalize((target_direction * i_target) + (current_direction * i_current));
95 }
96 */
97 /**
98     Move away from a point.
99 **/
100 vector steerlib_repell(entity this, vector point,float maximal_distance)
101 {
102     float distance;
103     vector direction;
104
105     distance = bound(0.001,vlen(this.origin - point),maximal_distance);
106     direction = normalize(this.origin - point);
107
108     return  direction * (1-(distance / maximal_distance));
109 }
110
111 /**
112     Try to keep at ideal_distance away from point
113 **/
114 vector steerlib_standoff(entity this, vector point,float ideal_distance)
115 {
116     float distance;
117     vector direction;
118
119     distance = vlen(this.origin - point);
120
121
122     if(distance < ideal_distance)
123     {
124         direction = normalize(this.origin - point);
125         return direction * (distance / ideal_distance);
126     }
127
128     direction = normalize(point - this.origin);
129     return direction * (ideal_distance / distance);
130
131 }
132
133 /**
134     A random heading in a forward halfcicrle
135
136     use like:
137     this.target = steerlib_wander(256,32,this.target)
138
139     where range is the cicrle radius and tresh is how close we need to be to pick a new heading.
140 **/
141 vector steerlib_wander(entity this, float range, float tresh, vector oldpoint)
142 {
143     vector wander_point;
144     wander_point = v_forward - oldpoint;
145
146     if (vlen(wander_point) > tresh)
147         return oldpoint;
148
149     range = bound(0,range,1);
150
151     wander_point = this.origin + v_forward * 128;
152     wander_point = wander_point + randomvec() * (range * 128) - randomvec() * (range * 128);
153
154     return normalize(wander_point - this.origin);
155 }
156
157 /**
158     Dodge a point. dont work to well.
159 **/
160 vector steerlib_dodge(entity this, vector point, vector dodge_dir, float min_distance)
161 {
162     float distance;
163
164     distance = max(vlen(this.origin - point),min_distance);
165     if (min_distance < distance)
166         return '0 0 0';
167
168     return dodge_dir * (min_distance/distance);
169 }
170
171 /**
172     flocking by .flock_id
173     Group will move towards the unified direction while keeping close to eachother.
174 **/
175 .float flock_id;
176 vector steerlib_flock(entity this, float _radius, float standoff,float separation_force,float flock_force)
177 {
178     entity flock_member;
179     vector push = '0 0 0', pull = '0 0 0';
180     float ccount = 0;
181
182     flock_member = findradius(this.origin, _radius);
183     while(flock_member)
184     {
185         if(flock_member != this)
186         if(flock_member.flock_id == this.flock_id)
187         {
188             ++ccount;
189             push = push + (steerlib_repell(this, flock_member.origin,standoff) * separation_force);
190             pull = pull + (steerlib_arrive(this, flock_member.origin + flock_member.velocity, _radius) * flock_force);
191         }
192         flock_member = flock_member.chain;
193     }
194     return push + (pull* (1 / ccount));
195 }
196
197 /**
198     flocking by .flock_id
199     Group will move towards the unified direction while keeping close to eachother.
200     xy only version (for ground movers).
201 **/
202 vector steerlib_flock2d(entity this, float _radius, float standoff,float separation_force,float flock_force)
203 {
204     entity flock_member;
205     vector push = '0 0 0', pull = '0 0 0';
206     float ccount = 0;
207
208     flock_member = findradius(this.origin,_radius);
209     while(flock_member)
210     {
211         if(flock_member != this)
212         if(flock_member.flock_id == this.flock_id)
213         {
214             ++ccount;
215             push = push + (steerlib_repell(this, flock_member.origin, standoff) * separation_force);
216             pull = pull + (steerlib_arrive(this, flock_member.origin + flock_member.velocity, _radius) * flock_force);
217         }
218         flock_member = flock_member.chain;
219     }
220
221     push.z = 0;
222     pull.z = 0;
223
224     return push + (pull * (1 / ccount));
225 }
226
227 /**
228     All members want to be in the center, and keep away from eachother.
229     The furtehr form the center the more they want to be there.
230
231     This results in a aligned movement (?!) much like flocking.
232 **/
233 vector steerlib_swarm(entity this, float _radius, float standoff,float separation_force,float swarm_force)
234 {
235     entity swarm_member;
236     vector force = '0 0 0', center = '0 0 0';
237     float ccount = 0;
238
239     swarm_member = findradius(this.origin,_radius);
240
241     while(swarm_member)
242     {
243         if(swarm_member.flock_id == this.flock_id)
244         {
245             ++ccount;
246             center = center + swarm_member.origin;
247             force = force + (steerlib_repell(this, swarm_member.origin,standoff) * separation_force);
248         }
249         swarm_member = swarm_member.chain;
250     }
251
252     center = center * (1 / ccount);
253     force = force + (steerlib_arrive(this, center,_radius) * swarm_force);
254
255     return force;
256 }
257
258 /**
259     Steer towards the direction least obstructed.
260     Run four tracelines in a forward funnel, bias each diretion negative if something is found there.
261     You need to call makevectors() (or equivalent) before this function to set v_forward and v_right
262 **/
263 vector steerlib_traceavoid(entity this, float pitch,float length)
264 {
265     vector vup_left,vup_right,vdown_left,vdown_right;
266     float fup_left,fup_right,fdown_left,fdown_right;
267     vector upwish,downwish,leftwish,rightwish;
268     vector v_left,v_down;
269
270
271     v_left = v_right * -1;
272     v_down = v_up * -1;
273
274     vup_left = (v_forward + (v_left * pitch + v_up * pitch)) * length;
275     traceline(this.origin, this.origin +  vup_left,MOVE_NOMONSTERS,this);
276     fup_left = trace_fraction;
277
278     //te_lightning1(NULL,this.origin, trace_endpos);
279
280     vup_right = (v_forward + (v_right * pitch + v_up * pitch)) * length;
281     traceline(this.origin,this.origin + vup_right ,MOVE_NOMONSTERS,this);
282     fup_right = trace_fraction;
283
284     //te_lightning1(NULL,this.origin, trace_endpos);
285
286     vdown_left = (v_forward + (v_left * pitch + v_down * pitch)) * length;
287     traceline(this.origin,this.origin + vdown_left,MOVE_NOMONSTERS,this);
288     fdown_left = trace_fraction;
289
290     //te_lightning1(NULL,this.origin, trace_endpos);
291
292     vdown_right = (v_forward + (v_right * pitch + v_down * pitch)) * length;
293     traceline(this.origin,this.origin + vdown_right,MOVE_NOMONSTERS,this);
294     fdown_right = trace_fraction;
295
296     //te_lightning1(NULL,this.origin, trace_endpos);
297     upwish    = v_up    * (fup_left   + fup_right);
298     downwish  = v_down  * (fdown_left + fdown_right);
299     leftwish  = v_left  * (fup_left   + fdown_left);
300     rightwish = v_right * (fup_right  + fdown_right);
301
302     return (upwish+leftwish+downwish+rightwish) * 0.25;
303
304 }
305
306 /**
307     Steer towards the direction least obstructed.
308     Run tracelines in a forward trident, bias each direction negative if something is found there.
309 **/
310 vector steerlib_traceavoid_flat(entity this, float pitch, float length, vector vofs)
311 {
312     vector vt_left, vt_right,vt_front;
313     float f_left, f_right,f_front;
314     vector leftwish, rightwish,frontwish, v_left;
315
316     v_left = v_right * -1;
317
318
319     vt_front = v_forward * length;
320     traceline(this.origin + vofs, this.origin + vofs + vt_front,MOVE_NOMONSTERS,this);
321     f_front = trace_fraction;
322
323     vt_left = (v_forward + (v_left * pitch)) * length;
324     traceline(this.origin + vofs, this.origin + vofs + vt_left,MOVE_NOMONSTERS,this);
325     f_left = trace_fraction;
326
327     //te_lightning1(NULL,this.origin, trace_endpos);
328
329     vt_right = (v_forward + (v_right * pitch)) * length;
330     traceline(this.origin + vofs, this.origin + vofs + vt_right ,MOVE_NOMONSTERS,this);
331     f_right = trace_fraction;
332
333     //te_lightning1(NULL,this.origin, trace_endpos);
334
335     leftwish  = v_left    * f_left;
336     rightwish = v_right   * f_right;
337     frontwish = v_forward * f_front;
338
339     return normalize(leftwish + rightwish + frontwish);
340 }
341
342 bool beamsweep_badpoint(vector point, bool waterok)
343 {
344     if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_SKY)
345         return true;
346
347     int pc = pointcontents(point);
348     int pc2 = pointcontents(point - '0 0 1');
349     
350     if(pc == CONTENT_EMPTY && pc2 == CONTENT_SOLID)
351         return false;
352     if(pc == CONTENT_EMPTY && pc2 == CONTENT_WATER && waterok)
353         return false;
354     if(pc == CONTENT_WATER && waterok)
355         return false;
356     return true;
357
358     /*switch(pc)
359     {
360         case CONTENT_SOLID: break;
361         case CONTENT_SLIME: break;
362         case CONTENT_LAVA:  break;
363
364         case CONTENT_SKY:
365             return true;
366
367         case CONTENT_EMPTY:
368             if (pc2 == CONTENT_SOLID)
369                 return 0;
370
371             if (pc2 == CONTENT_WATER)
372                 if(waterok)
373                     return 0;
374
375             break;
376
377         case CONTENT_WATER:
378             if(waterok)
379                 return 0;
380
381             break;
382     }
383
384     return true;*/
385 }
386
387 //#define BEAMSTEER_VISUAL
388 float beamsweep(entity this, vector from, vector dir,float length, float step,float step_up, float step_down)
389 {
390     float i;
391     vector a, b, u, d;
392
393     u = '0 0 1' * step_up;
394     d = '0 0 1' * step_down;
395
396     traceline(from + u, from - d,MOVE_NORMAL,this);
397     if(trace_fraction == 1.0)
398         return 0;
399
400     if(beamsweep_badpoint(trace_endpos,0))
401         return 0;
402
403     a = trace_endpos;
404     for(i = 0; i < length; i += step)
405     {
406
407         b = a + dir * step;
408         tracebox(a + u,'-4 -4 -4','4 4 4', b + u,MOVE_NORMAL,this);
409         if(trace_fraction != 1.0)
410             return i / length;
411
412         traceline(b + u, b - d,MOVE_NORMAL,this);
413         if(trace_fraction == 1.0)
414             return i / length;
415
416         if(beamsweep_badpoint(trace_endpos,0))
417             return i / length;
418 #ifdef BEAMSTEER_VISUAL
419         te_lightning1(NULL,a+u,b+u);
420         te_lightning1(NULL,b+u,b-d);
421 #endif
422         a = trace_endpos;
423     }
424
425     return 1;
426 }
427
428 vector steerlib_beamsteer(entity this, vector dir, float length, float step, float step_up, float step_down)
429 {
430     float bm_forward, bm_right, bm_left,p;
431     vector vr,vl;
432
433     dir.z *= 0.15;
434     vr = vectoangles(dir);
435     //vr_x *= -1;
436
437     tracebox(this.origin + '0 0 1' * step_up, this.mins, this.maxs, ('0 0 1' * step_up) + this.origin +  (dir * length), MOVE_NOMONSTERS, this);
438     if(trace_fraction == 1.0)
439     {
440         //te_lightning1(this,this.origin,this.origin +  (dir * length));
441         return dir;
442     }
443
444     makevectors(vr);
445     bm_forward = beamsweep(this, this.origin, v_forward, length, step, step_up, step_down);
446
447     vr = normalize(v_forward + v_right * 0.125);
448     vl = normalize(v_forward - v_right * 0.125);
449
450     bm_right = beamsweep(this, this.origin, vr, length, step, step_up, step_down);
451     bm_left  = beamsweep(this, this.origin, vl, length, step, step_up, step_down);
452
453
454     p = bm_left + bm_right;
455     if(p == 2)
456     {
457         //te_lightning1(this,this.origin + '0 0 32',this.origin + '0 0 32' + vr * length);
458         //te_lightning1(this.tur_head,this.origin + '0 0 32',this.origin + '0 0 32' + vl * length);
459
460         return v_forward;
461     }
462
463     p = 2 - p;
464
465     vr = normalize(v_forward + v_right * p);
466     vl = normalize(v_forward - v_right * p);
467     bm_right = beamsweep(this, this.origin, vr, length, step, step_up, step_down);
468     bm_left  = beamsweep(this, this.origin, vl, length, step, step_up, step_down);
469
470
471     if(bm_left + bm_right < 0.15)
472     {
473         vr = normalize((v_forward*-1) + v_right * 0.90);
474         vl = normalize((v_forward*-1) - v_right * 0.90);
475
476         bm_right = beamsweep(this, this.origin, vr, length, step, step_up, step_down);
477         bm_left  = beamsweep(this, this.origin, vl, length, step, step_up, step_down);
478     }
479
480     //te_lightning1(this,this.origin + '0 0 32',this.origin + '0 0 32' + vr * length);
481     //te_lightning1(this.tur_head,this.origin + '0 0 32',this.origin + '0 0 32' + vl * length);
482
483     bm_forward *= bm_forward;
484     bm_right   *= bm_right;
485     bm_left    *= bm_left;
486
487     vr = vr * bm_right;
488     vl = vl * bm_left;
489
490     return normalize(vr + vl);
491
492 }
493
494
495 //////////////////////////////////////////////
496 //     Testting                             //
497 // Everything below this point is a mess :D //
498 //////////////////////////////////////////////
499 //#define TLIBS_TETSLIBS
500 #ifdef TLIBS_TETSLIBS
501 void flocker_die(entity this)
502 {
503         Send_Effect(EFFECT_ROCKET_EXPLODE, this.origin, '0 0 0', 1);
504
505     this.owner.cnt += 1;
506     this.owner = NULL;
507
508     this.nextthink = time;
509     setthink(this, SUB_Remove);
510 }
511
512
513 void flocker_think(entity this)
514 {
515     vector dodgemove,swarmmove;
516     vector reprellmove,wandermove,newmove;
517
518     this.angles_x = this.angles.x * -1;
519     makevectors(this.angles);
520     this.angles_x = this.angles.x * -1;
521
522     dodgemove   = steerlib_traceavoid(this, 0.35,1000);
523     swarmmove   = steerlib_flock(this, 500,75,700,500);
524     reprellmove = steerlib_repell(this, this.owner.enemy.origin+this.enemy.velocity,2000) * 700;
525
526     if(dodgemove == '0 0 0')
527     {
528         this.pos1 = steerlib_wander(this, 0.5,0.1,this.pos1);
529         wandermove  = this.pos1 * 50;
530     }
531     else
532         this.pos1 = normalize(this.velocity);
533
534     dodgemove = dodgemove * vlen(this.velocity) * 5;
535
536     newmove = swarmmove + reprellmove + wandermove + dodgemove;
537     this.velocity = movelib_inertmove_byspeed(this, newmove,300,0.2,0.9);
538     //this.velocity  = movelib_inertmove(this, dodgemove,0.65);
539
540     this.velocity = movelib_dragvec(this, 0.01,0.6);
541
542     this.angles = vectoangles(this.velocity);
543
544     if(this.health <= 0)
545         flocker_die(this);
546     else
547         this.nextthink = time + 0.1;
548 }
549
550 MODEL(FLOCKER, "models/turrets/rocket.md3");
551
552 void spawn_flocker(entity this)
553 {
554     entity flocker = new(flocker);
555
556     setorigin(flocker, this.origin + '0 0 32');
557     setmodel (flocker, MDL_FLOCKER);
558     setsize (flocker, '-3 -3 -3', '3 3 3');
559
560     flocker.flock_id   = this.flock_id;
561     flocker.owner      = this;
562     setthink(flocker, flocker_think);
563     flocker.nextthink  = time + random() * 5;
564     PROJECTILE_MAKETRIGGER(flocker);
565     set_movetype(flocker, MOVETYPE_BOUNCEMISSILE);
566     flocker.effects    = EF_LOWPRECISION;
567     flocker.velocity   = randomvec() * 300;
568     flocker.angles     = vectoangles(flocker.velocity);
569     flocker.health     = 10;
570     flocker.pos1      = normalize(flocker.velocity + randomvec() * 0.1);
571
572     this.cnt = this.cnt -1;
573
574 }
575
576 void flockerspawn_think(entity this)
577 {
578     if(this.cnt > 0)
579         spawn_flocker(this);
580
581     this.nextthink = time + this.delay;
582
583 }
584
585 void flocker_hunter_think(entity this)
586 {
587     vector dodgemove,attractmove,newmove;
588     entity ee;
589
590     this.angles_x = this.angles.x * -1;
591     makevectors(this.angles);
592     this.angles_x = this.angles.x * -1;
593
594     if(this.enemy)
595     if(vdist(this.enemy.origin - this.origin, <, 64))
596     {
597         ee = this.enemy;
598         ee.health = -1;
599         this.enemy = NULL;
600
601     }
602
603     if(!this.enemy)
604     {
605         FOREACH_ENTITY_FLOAT(flock_id, this.flock_id,
606         {
607             if(it == this.owner || it == ee)
608                 continue;
609
610             if(!this.enemy || vlen2(this.origin - it.origin) > vlen2(this.origin - this.enemy.origin))
611                 this.enemy = it;
612         });
613     }
614
615     if(this.enemy)
616         attractmove = steerlib_attract(this, this.enemy.origin+this.enemy.velocity * 0.1,5000) * 1250;
617     else
618         attractmove = normalize(this.velocity) * 200;
619
620     dodgemove = steerlib_traceavoid(this, 0.35,1500) * vlen(this.velocity);
621
622     newmove = dodgemove + attractmove;
623     this.velocity = movelib_inertmove_byspeed(this, newmove,1250,0.3,0.7);
624     this.velocity = movelib_dragvec(this, 0.01,0.5);
625
626     this.angles = vectoangles(this.velocity);
627     this.nextthink = time + 0.1;
628 }
629
630
631 float globflockcnt;
632 spawnfunc(flockerspawn)
633 {
634     ++globflockcnt;
635
636     if(!this.cnt)      this.cnt = 20;
637     if(!this.delay)    this.delay = 0.25;
638     if(!this.flock_id) this.flock_id = globflockcnt;
639
640     setthink(this, flockerspawn_think);
641     this.nextthink = time + 0.25;
642
643     this.enemy = new(FLock Hunter);
644
645     setmodel(this.enemy, MDL_FLOCKER);
646     setorigin(this.enemy, this.origin + '0 0 768' + (randomvec() * 128));
647
648     this.enemy.scale     = 3;
649     this.enemy.effects   = EF_LOWPRECISION;
650     set_movetype(this.enemy, MOVETYPE_BOUNCEMISSILE);
651     PROJECTILE_MAKETRIGGER(this.enemy);
652     setthink(this.enemy, flocker_hunter_think);
653     this.enemy.nextthink = time + 10;
654     this.enemy.flock_id  = this.flock_id;
655     this.enemy.owner     = this;
656 }
657 #endif
658
659
660