]> git.xonotic.org Git - xonotic/xonotic-data.pk3dir.git/blob - qcsrc/common/mutators/mutator/waypoints/waypointsprites.qc
Merge branch 'master' into TimePath/deathtypes
[xonotic/xonotic-data.pk3dir.git] / qcsrc / common / mutators / mutator / waypoints / waypointsprites.qc
1 #include "waypointsprites.qh"
2
3 #ifdef IMPLEMENTATION
4
5 REGISTER_MUTATOR(waypointsprites, true);
6
7 #ifdef SVQC
8 /** flags origin [team displayrule] [spritename] [spritename2] [spritename3] [lifetime maxdistance hideable] */
9 bool WaypointSprite_SendEntity(entity this, entity to, float sendflags)
10 {
11     WriteMutator(MSG_ENTITY, waypointsprites);
12
13     sendflags = sendflags & 0x7F;
14
15     if (g_nexball)
16         sendflags &= ~0x80;
17     else if (self.max_health || (self.pain_finished && (time < self.pain_finished + 0.25)))
18         sendflags |= 0x80;
19
20     WriteByte(MSG_ENTITY, sendflags);
21     WriteByte(MSG_ENTITY, self.wp_extra);
22
23     if (sendflags & 0x80)
24     {
25         if (self.max_health)
26         {
27             WriteByte(MSG_ENTITY, (self.health / self.max_health) * 191.0);
28         }
29         else
30         {
31             float dt = self.pain_finished - time;
32             dt = bound(0, dt * 32, 16383);
33             WriteByte(MSG_ENTITY, (dt & 0xFF00) / 256 + 192);
34             WriteByte(MSG_ENTITY, (dt & 0x00FF));
35         }
36     }
37
38     if (sendflags & 64)
39     {
40         WriteCoord(MSG_ENTITY, self.origin.x);
41         WriteCoord(MSG_ENTITY, self.origin.y);
42         WriteCoord(MSG_ENTITY, self.origin.z);
43     }
44
45     if (sendflags & 1)
46     {
47         WriteByte(MSG_ENTITY, self.team);
48         WriteByte(MSG_ENTITY, self.rule);
49     }
50
51     if (sendflags & 2)
52         WriteString(MSG_ENTITY, self.model1);
53
54     if (sendflags & 4)
55         WriteString(MSG_ENTITY, self.model2);
56
57     if (sendflags & 8)
58         WriteString(MSG_ENTITY, self.model3);
59
60     if (sendflags & 16)
61     {
62         WriteCoord(MSG_ENTITY, self.fade_time);
63         WriteCoord(MSG_ENTITY, self.teleport_time);
64         WriteShort(MSG_ENTITY, self.fade_rate); // maxdist
65         float f = 0;
66         if (self.currentammo)
67             f |= 1; // hideable
68         if (self.exteriormodeltoclient == to)
69             f |= 2; // my own
70         if (g_onslaught)
71         {
72             if (self.owner.classname == "onslaught_controlpoint")
73             {
74                 entity wp_owner = self.owner;
75                 entity e = WaypointSprite_getviewentity(to);
76                 if (SAME_TEAM(e, wp_owner) && wp_owner.goalentity.health >= wp_owner.goalentity.max_health) { f |= 2; }
77                 if (!ons_ControlPoint_Attackable(wp_owner, e.team)) { f |= 2; }
78             }
79             if (self.owner.classname == "onslaught_generator")
80             {
81                 entity wp_owner = self.owner;
82                 if (wp_owner.isshielded && wp_owner.health >= wp_owner.max_health) { f |= 2; }
83                 if (wp_owner.health <= 0) { f |= 2; }
84             }
85         }
86         WriteByte(MSG_ENTITY, f);
87     }
88
89     if (sendflags & 32)
90     {
91         WriteByte(MSG_ENTITY, self.cnt); // icon on radar
92         WriteByte(MSG_ENTITY, self.colormod.x * 255.0);
93         WriteByte(MSG_ENTITY, self.colormod.y * 255.0);
94         WriteByte(MSG_ENTITY, self.colormod.z * 255.0);
95
96         if (WaypointSprite_isteammate(self.owner, WaypointSprite_getviewentity(to)))
97         {
98             float dt = (self.waypointsprite_helpmetime - time) / 0.1;
99             if (dt < 0)
100                 dt = 0;
101             if (dt > 255)
102                 dt = 255;
103             WriteByte(MSG_ENTITY, dt);
104         }
105         else
106             WriteByte(MSG_ENTITY, 0);
107     }
108
109     return true;
110 }
111 #endif
112
113 #ifdef CSQC
114 void Ent_WaypointSprite();
115 MUTATOR_HOOKFUNCTION(waypointsprites, CSQC_Ent_Update) {
116     if (MUTATOR_RETURNVALUE) return false;
117     if (!ReadMutatorEquals(mutator_argv_int_0, waypointsprites)) return false;
118     Ent_WaypointSprite();
119     return true;
120 }
121
122 void Ent_RemoveWaypointSprite()
123 {SELFPARAM();
124     if (self.netname) strunzone(self.netname);
125     if (self.netname2) strunzone(self.netname2);
126     if (self.netname3) strunzone(self.netname3);
127 }
128
129 /** flags origin [team displayrule] [spritename] [spritename2] [spritename3] [lifetime maxdistance hideable] */
130 void Ent_WaypointSprite()
131 {SELFPARAM();
132     int sendflags = ReadByte();
133     self.wp_extra = ReadByte();
134
135     if (!self.spawntime)
136         self.spawntime = time;
137
138     self.draw2d = Draw_WaypointSprite;
139
140     InterpolateOrigin_Undo();
141     self.iflags |= IFLAG_ORIGIN;
142
143     if (sendflags & 0x80)
144     {
145         int t = ReadByte();
146         if (t < 192)
147         {
148             self.health = t / 191.0;
149             self.build_finished = 0;
150         }
151         else
152         {
153             t = (t - 192) * 256 + ReadByte();
154             self.build_started = servertime;
155             if (self.build_finished)
156                 self.build_starthealth = bound(0, self.health, 1);
157             else
158                 self.build_starthealth = 0;
159             self.build_finished = servertime + t / 32;
160         }
161     }
162     else
163     {
164         self.health = -1;
165         self.build_finished = 0;
166     }
167
168     if (sendflags & 64)
169     {
170         // unfortunately, this needs to be exact (for the 3D display)
171         self.origin_x = ReadCoord();
172         self.origin_y = ReadCoord();
173         self.origin_z = ReadCoord();
174         setorigin(self, self.origin);
175     }
176
177     if (sendflags & 1)
178     {
179         self.team = ReadByte();
180         self.rule = ReadByte();
181     }
182
183     if (sendflags & 2)
184     {
185         if (self.netname)
186             strunzone(self.netname);
187         self.netname = strzone(ReadString());
188     }
189
190     if (sendflags & 4)
191     {
192         if (self.netname2)
193             strunzone(self.netname2);
194         self.netname2 = strzone(ReadString());
195     }
196
197     if (sendflags & 8)
198     {
199         if (self.netname3)
200             strunzone(self.netname3);
201         self.netname3 = strzone(ReadString());
202     }
203
204     if (sendflags & 16)
205     {
206         self.lifetime = ReadCoord();
207         self.fadetime = ReadCoord();
208         self.maxdistance = ReadShort();
209         self.hideflags = ReadByte();
210     }
211
212     if (sendflags & 32)
213     {
214         int f = ReadByte();
215         self.teamradar_icon = f & BITS(7);
216         if (f & BIT(7))
217         {
218             self.(teamradar_times[self.teamradar_time_index]) = time;
219             self.teamradar_time_index = (self.teamradar_time_index + 1) % MAX_TEAMRADAR_TIMES;
220         }
221         self.teamradar_color_x = ReadByte() / 255.0;
222         self.teamradar_color_y = ReadByte() / 255.0;
223         self.teamradar_color_z = ReadByte() / 255.0;
224         self.helpme = ReadByte() * 0.1;
225         if (self.helpme > 0)
226             self.helpme += servertime;
227     }
228
229     InterpolateOrigin_Note();
230
231     self.entremove = Ent_RemoveWaypointSprite;
232 }
233 #endif
234
235 #ifdef CSQC
236 float spritelookupblinkvalue(string s)
237 {SELFPARAM();
238     if (s == WP_Weapon.netname) {
239         if (get_weaponinfo(self.wp_extra).spawnflags & WEP_FLAG_SUPERWEAPON)
240             return 2;
241     }
242     if (s == WP_Item.netname) return Items[self.wp_extra].m_waypointblink;
243
244     return 1;
245 }
246
247 vector spritelookupcolor(entity this, string s, vector def)
248 {
249     if (s == WP_Weapon.netname  || s == RADARICON_Weapon.netname) return get_weaponinfo(this.wp_extra).wpcolor;
250     if (s == WP_Item.netname    || s == RADARICON_Item.netname) return Items[this.wp_extra].m_color;
251     if (s == WP_Buff.netname    || s == RADARICON_Buff.netname) return Buffs[this.wp_extra].m_color;
252     return def;
253 }
254
255 string spritelookuptext(string s)
256 {SELFPARAM();
257     if (s == WP_RaceStartFinish.netname) return (race_checkpointtime || race_mycheckpointtime) ? _("Finish") : _("Start");
258     if (s == WP_Weapon.netname) return get_weaponinfo(self.wp_extra).message;
259     if (s == WP_Item.netname) return Items[self.wp_extra].m_waypoint;
260     if (s == WP_Buff.netname) return Buffs[self.wp_extra].m_prettyName;
261     if (s == WP_Monster.netname) return get_monsterinfo(self.wp_extra).monster_name;
262
263     // need to loop, as our netname could be one of three
264     FOREACH(Waypoints, it.netname == s, LAMBDA(
265         return it.m_name;
266     ));
267
268     return s;
269 }
270 #endif
271
272 #ifdef CSQC
273 void drawrotpic(vector org, float rot, string pic, vector sz, vector hotspot, vector rgb, float a, float f)
274 {
275     vector v1, v2, v3, v4;
276
277     hotspot = -1 * hotspot;
278
279     // hotspot-relative coordinates of the corners
280     v1 = hotspot;
281     v2 = hotspot + '1 0 0' * sz.x;
282     v3 = hotspot + '1 0 0' * sz.x + '0 1 0' * sz.y;
283     v4 = hotspot                  + '0 1 0' * sz.y;
284
285     // rotate them, and make them absolute
286     rot = -rot; // rotate by the opposite angle, as our coordinate system is reversed
287     v1 = rotate(v1, rot) + org;
288     v2 = rotate(v2, rot) + org;
289     v3 = rotate(v3, rot) + org;
290     v4 = rotate(v4, rot) + org;
291
292     // draw them
293     R_BeginPolygon(pic, f);
294     R_PolygonVertex(v1, '0 0 0', rgb, a);
295     R_PolygonVertex(v2, '1 0 0', rgb, a);
296     R_PolygonVertex(v3, '1 1 0', rgb, a);
297     R_PolygonVertex(v4, '0 1 0', rgb, a);
298     R_EndPolygon();
299 }
300
301 void drawquad(vector o, vector ri, vector up, string pic, vector rgb, float a, float f)
302 {
303     R_BeginPolygon(pic, f);
304     R_PolygonVertex(o, '0 0 0', rgb, a);
305     R_PolygonVertex(o + ri, '1 0 0', rgb, a);
306     R_PolygonVertex(o + up + ri, '1 1 0', rgb, a);
307     R_PolygonVertex(o + up, '0 1 0', rgb, a);
308     R_EndPolygon();
309 }
310
311 void drawhealthbar(vector org, float rot, float h, vector sz, vector hotspot, float width, float theheight, float margin, float border, float align, vector rgb, float a, vector hrgb, float ha, float f)
312 {
313     vector o, ri, up;
314     float owidth; // outer width
315
316     hotspot = -1 * hotspot;
317
318     // hotspot-relative coordinates of the healthbar corners
319     o = hotspot;
320     ri = '1 0 0';
321     up = '0 1 0';
322
323     rot = -rot; // rotate by the opposite angle, as our coordinate system is reversed
324     o = rotate(o, rot) + org;
325     ri = rotate(ri, rot);
326     up = rotate(up, rot);
327
328     owidth = width + 2 * border;
329     o = o - up * (margin + border + theheight) + ri * (sz.x - owidth) * 0.5;
330
331     drawquad(o - up * border,                               ri * owidth,    up * border,    "", rgb,  a,  f);
332     drawquad(o + up * theheight,                            ri * owidth,    up * border,    "", rgb,  a,  f);
333     drawquad(o,                                             ri * border,    up * theheight, "", rgb,  a,  f);
334     drawquad(o + ri * (owidth - border),                    ri * border,    up * theheight, "", rgb,  a,  f);
335     drawquad(o + ri * (border + align * ((1 - h) * width)), ri * width * h, up * theheight, "", hrgb, ha, f);
336 }
337
338 // returns location of sprite text
339 vector drawspritearrow(vector o, float ang, vector rgb, float a, float t)
340 {
341     float size   = 9.0 * t;
342     float border = 1.5 * t;
343     float margin = 4.0 * t;
344
345     float borderDiag = border * 1.414;
346     vector arrowX  = eX * size;
347     vector arrowY  = eY * (size+borderDiag);
348     vector borderX = eX * (size+borderDiag);
349     vector borderY = eY * (size+borderDiag+border);
350
351     R_BeginPolygon("", DRAWFLAG_NORMAL);
352     R_PolygonVertex(o,                                  '0 0 0', '0 0 0', a);
353     R_PolygonVertex(o + rotate(arrowY  - borderX, ang), '0 0 0', '0 0 0', a);
354     R_PolygonVertex(o + rotate(borderY - borderX, ang), '0 0 0', '0 0 0', a);
355     R_PolygonVertex(o + rotate(borderY + borderX, ang), '0 0 0', '0 0 0', a);
356     R_PolygonVertex(o + rotate(arrowY  + borderX, ang), '0 0 0', '0 0 0', a);
357     R_EndPolygon();
358
359     R_BeginPolygon("", DRAWFLAG_ADDITIVE);
360     R_PolygonVertex(o + rotate(eY * borderDiag, ang), '0 0 0', rgb, a);
361     R_PolygonVertex(o + rotate(arrowY - arrowX, ang), '0 0 0', rgb, a);
362     R_PolygonVertex(o + rotate(arrowY + arrowX, ang), '0 0 0', rgb, a);
363     R_EndPolygon();
364
365     return o + rotate(eY * (borderDiag+size+margin), ang);
366 }
367
368 // returns location of sprite healthbar
369 vector drawspritetext(vector o, float ang, float minwidth, vector rgb, float a, vector fontsize, string s)
370 {
371     float algnx, algny;
372     float sw, w, h;
373     float aspect, sa, ca;
374
375     sw = stringwidth(s, false, fontsize);
376     if (sw > minwidth)
377         w = sw;
378     else
379         w = minwidth;
380     h = fontsize.y;
381
382     // how do corners work?
383     aspect = vid_conwidth / vid_conheight;
384     sa = sin(ang);
385     ca = cos(ang) * aspect;
386     if (fabs(sa) > fabs(ca))
387     {
388         algnx = (sa < 0);
389         algny = 0.5 - 0.5 * ca / fabs(sa);
390     }
391     else
392     {
393         algnx = 0.5 - 0.5 * sa / fabs(ca);
394         algny = (ca < 0);
395     }
396
397     // align
398     o.x -= w * algnx;
399     o.y -= h * algny;
400
401     // we want to be onscreen
402     if (o.x < 0)
403         o.x = 0;
404     if (o.y < 0)
405         o.y = 0;
406     if (o.x > vid_conwidth - w)
407         o.x = vid_conwidth - w;
408     if (o.y > vid_conheight - h)
409         o.x = vid_conheight - h;
410
411     o.x += 0.5 * (w - sw);
412
413     drawstring(o, s, fontsize, rgb, a, DRAWFLAG_NORMAL);
414
415     o.x += 0.5 * sw;
416     o.y += 0.5 * h;
417
418     return o;
419 }
420
421 vector fixrgbexcess_move(vector rgb, vector src, vector dst)
422 {
423     vector yvec = '0.299 0.587 0.114';
424     return rgb + dst * ((src * yvec) / (dst * yvec)) * ((rgb - '1 1 1') * src);
425 }
426
427 vector fixrgbexcess(vector rgb)
428 {
429     if (rgb.x > 1) {
430         rgb = fixrgbexcess_move(rgb, '1 0 0', '0 1 1');
431         if (rgb.y > 1) {
432             rgb = fixrgbexcess_move(rgb, '0 1 0', '0 0 1');
433             if (rgb.z > 1) rgb.z = 1;
434         } else if (rgb.z > 1) {
435             rgb = fixrgbexcess_move(rgb, '0 0 1', '0 1 0');
436             if (rgb.y > 1) rgb.y = 1;
437         }
438     } else if (rgb.y > 1) {
439         rgb = fixrgbexcess_move(rgb, '0 1 0', '1 0 1');
440         if (rgb.x > 1) {
441             rgb = fixrgbexcess_move(rgb, '1 0 0', '0 0 1');
442             if (rgb.z > 1) rgb.z = 1;
443         } else if (rgb.z > 1) {
444             rgb = fixrgbexcess_move(rgb, '0 0 1', '1 0 0');
445             if (rgb.x > 1) rgb.x = 1;
446         }
447     } else if (rgb.z > 1) {
448         rgb = fixrgbexcess_move(rgb, '0 0 1', '1 1 0');
449         if (rgb.x > 1) {
450             rgb = fixrgbexcess_move(rgb, '1 0 0', '0 1 0');
451             if (rgb.y > 1) rgb.y = 1;
452         } else if (rgb.y > 1) {
453             rgb = fixrgbexcess_move(rgb, '0 1 0', '1 0 0');
454             if (rgb.x > 1) rgb.x = 1;
455         }
456     }
457     return rgb;
458 }
459
460 void Draw_WaypointSprite(entity this)
461 {
462     if (self.lifetime)
463         self.alpha = pow(bound(0, (self.fadetime - time) / self.lifetime, 1), waypointsprite_timealphaexponent);
464     else
465         self.alpha = 1;
466
467     if (self.hideflags & 2)
468         return; // radar only
469
470     if (autocvar_cl_hidewaypoints >= 2)
471         return;
472
473     if (self.hideflags & 1)
474         if (autocvar_cl_hidewaypoints)
475             return; // fixed waypoint
476
477     InterpolateOrigin_Do();
478
479     float t = GetPlayerColor(player_localnum) + 1;
480
481     string spriteimage = "";
482
483     // choose the sprite
484     switch (self.rule)
485     {
486         case SPRITERULE_SPECTATOR:
487             if (!(
488                 (autocvar_g_waypointsprite_itemstime == 1 && t == NUM_SPECTATOR + 1)
489             ||  (autocvar_g_waypointsprite_itemstime == 2 && (t == NUM_SPECTATOR + 1 || warmup_stage))
490                 ))
491                 return;
492             spriteimage = self.netname;
493             break;
494         case SPRITERULE_DEFAULT:
495             if (self.team)
496             {
497                 if (self.team == t)
498                     spriteimage = self.netname;
499                 else
500                     spriteimage = "";
501             }
502             else
503                 spriteimage = self.netname;
504             break;
505         case SPRITERULE_TEAMPLAY:
506             if (t == NUM_SPECTATOR + 1)
507                 spriteimage = self.netname3;
508             else if (self.team == t)
509                 spriteimage = self.netname2;
510             else
511                 spriteimage = self.netname;
512             break;
513         default:
514             error("Invalid waypointsprite rule!");
515             break;
516     }
517
518     if (spriteimage == "")
519         return;
520
521     ++waypointsprite_newcount;
522
523     float dist;
524     dist = vlen(self.origin - view_origin);
525
526     float a;
527     a = self.alpha * autocvar_hud_panel_fg_alpha;
528
529     if (self.maxdistance > waypointsprite_normdistance)
530         a *= pow(bound(0, (self.maxdistance - dist) / (self.maxdistance - waypointsprite_normdistance), 1), waypointsprite_distancealphaexponent);
531     else if (self.maxdistance > 0)
532         a *= pow(bound(0, (waypointsprite_fadedistance - dist) / (waypointsprite_fadedistance - waypointsprite_normdistance), 1), waypointsprite_distancealphaexponent) * (1 - waypointsprite_minalpha) + waypointsprite_minalpha;
533
534     vector rgb = spritelookupcolor(self, spriteimage, self.teamradar_color);
535     if (rgb == '0 0 0')
536     {
537         self.teamradar_color = '1 0 1';
538         LOG_INFOF("WARNING: sprite of name %s has no color, using pink so you notice it\n", spriteimage);
539     }
540
541     if (time - floor(time) > 0.5)
542     {
543         if (self.helpme && time < self.helpme)
544             a *= SPRITE_HELPME_BLINK;
545         else if (!self.lifetime) // fading out waypoints don't blink
546             a *= spritelookupblinkvalue(spriteimage);
547     }
548
549     if (a > 1)
550     {
551         rgb *= a;
552         a = 1;
553     }
554
555     if (a <= 0.003)
556         return;
557
558     rgb = fixrgbexcess(rgb);
559
560     vector o;
561     float ang;
562
563     o = project_3d_to_2d(self.origin);
564     if (o.z < 0
565     || o.x < (vid_conwidth * waypointsprite_edgeoffset_left)
566     || o.y < (vid_conheight * waypointsprite_edgeoffset_top)
567     || o.x > (vid_conwidth - (vid_conwidth * waypointsprite_edgeoffset_right))
568     || o.y > (vid_conheight - (vid_conheight * waypointsprite_edgeoffset_bottom)))
569     {
570         // scale it to be just in view
571         vector d;
572         float f1, f2;
573
574         d = o - '0.5 0 0' * vid_conwidth - '0 0.5 0' * vid_conheight;
575         ang = atan2(-d.x, -d.y);
576         if (o.z < 0)
577             ang += M_PI;
578
579         f1 = d.x / vid_conwidth;
580         f2 = d.y / vid_conheight;
581
582         if (max(f1, -f1) > max(f2, -f2)) {
583             if (d.z * f1 > 0) {
584                 // RIGHT edge
585                 d = d * ((0.5 - waypointsprite_edgeoffset_right) / f1);
586             } else {
587                 // LEFT edge
588                 d = d * (-(0.5 - waypointsprite_edgeoffset_left) / f1);
589             }
590         } else {
591             if (d.z * f2 > 0) {
592                 // BOTTOM edge
593                 d = d * ((0.5 - waypointsprite_edgeoffset_bottom) / f2);
594             } else {
595                 // TOP edge
596                 d = d * (-(0.5 - waypointsprite_edgeoffset_top) / f2);
597             }
598         }
599
600         o = d + '0.5 0 0' * vid_conwidth + '0 0.5 0' * vid_conheight;
601     }
602     else
603     {
604 #if 1
605         ang = M_PI;
606 #else
607         vector d;
608         d = o - '0.5 0 0' * vid_conwidth - '0 0.5 0' * vid_conheight;
609         ang = atan2(-d.x, -d.y);
610 #endif
611     }
612     o.z = 0;
613
614     float edgedistance_min = min((o.y - (vid_conheight * waypointsprite_edgeoffset_top)),
615     (o.x - (vid_conwidth * waypointsprite_edgeoffset_left)),
616     (vid_conwidth - (vid_conwidth * waypointsprite_edgeoffset_right)) - o.x,
617     (vid_conheight - (vid_conheight * waypointsprite_edgeoffset_bottom)) - o.y);
618
619     float vidscale = max(vid_conwidth / vid_width, vid_conheight / vid_height);
620
621     float crosshairdistance = sqrt( pow(o.x - vid_conwidth/2, 2) + pow(o.y - vid_conheight/2, 2) );
622
623     t = waypointsprite_scale * vidscale;
624     a *= waypointsprite_alpha;
625
626     {
627         a = a * (1 - (1 - waypointsprite_distancefadealpha) * (bound(0, dist/waypointsprite_distancefadedistance, 1)));
628         t = t * (1 - (1 - waypointsprite_distancefadescale) * (bound(0, dist/waypointsprite_distancefadedistance, 1)));
629     }
630     if (edgedistance_min < waypointsprite_edgefadedistance) {
631         a = a * (1 - (1 - waypointsprite_edgefadealpha) * (1 - bound(0, edgedistance_min/waypointsprite_edgefadedistance, 1)));
632         t = t * (1 - (1 - waypointsprite_edgefadescale) * (1 - bound(0, edgedistance_min/waypointsprite_edgefadedistance, 1)));
633     }
634     if (crosshairdistance < waypointsprite_crosshairfadedistance) {
635         a = a * (1 - (1 - waypointsprite_crosshairfadealpha) * (1 - bound(0, crosshairdistance/waypointsprite_crosshairfadedistance, 1)));
636         t = t * (1 - (1 - waypointsprite_crosshairfadescale) * (1 - bound(0, crosshairdistance/waypointsprite_crosshairfadedistance, 1)));
637     }
638
639     if (self.build_finished)
640     {
641         if (time < self.build_finished + 0.25)
642         {
643             if (time < self.build_started)
644                 self.health = self.build_starthealth;
645             else if (time < self.build_finished)
646                 self.health = (time - self.build_started) / (self.build_finished - self.build_started) * (1 - self.build_starthealth) + self.build_starthealth;
647             else
648                 self.health = 1;
649         }
650         else
651             self.health = -1;
652     }
653
654     o = drawspritearrow(o, ang, rgb, a, SPRITE_ARROW_SCALE * t);
655
656     string txt;
657     if (autocvar_g_waypointsprite_spam && waypointsprite_count >= autocvar_g_waypointsprite_spam)
658         txt = _("Spam");
659     else
660         txt = spritelookuptext(spriteimage);
661     if (self.helpme && time < self.helpme)
662         txt = sprintf(_("%s needing help!"), txt);
663     if (autocvar_g_waypointsprite_uppercase)
664         txt = strtoupper(txt);
665
666     draw_beginBoldFont();
667     if (self.health >= 0)
668     {
669         o = drawspritetext(o, ang, (SPRITE_HEALTHBAR_WIDTH + 2 * SPRITE_HEALTHBAR_BORDER) * t, rgb, a, waypointsprite_fontsize * '1 1 0', txt);
670
671         float align, marg;
672         if (self.build_finished)
673             align = 0.5;
674         else
675             align = 0;
676         if (cos(ang) > 0)
677             marg = -(SPRITE_HEALTHBAR_MARGIN + SPRITE_HEALTHBAR_HEIGHT + 2 * SPRITE_HEALTHBAR_BORDER) * t - 0.5 * waypointsprite_fontsize;
678         else
679             marg = SPRITE_HEALTHBAR_MARGIN * t + 0.5 * waypointsprite_fontsize;
680         drawhealthbar(
681                 o,
682                 0,
683                 self.health,
684                 '0 0 0',
685                 '0 0 0',
686                 SPRITE_HEALTHBAR_WIDTH * t,
687                 SPRITE_HEALTHBAR_HEIGHT * t,
688                 marg,
689                 SPRITE_HEALTHBAR_BORDER * t,
690                 align,
691                 rgb,
692                 a * SPRITE_HEALTHBAR_BORDERALPHA,
693                 rgb,
694                 a * SPRITE_HEALTHBAR_HEALTHALPHA,
695                 DRAWFLAG_NORMAL
696                  );
697     }
698     else
699     {
700         o = drawspritetext(o, ang, 0, rgb, a, waypointsprite_fontsize * '1 1 0', txt);
701     }
702     draw_endBoldFont();
703 }
704
705 void WaypointSprite_Load_Frames(string ext)
706 {
707     int dh = search_begin(strcat("models/sprites/*_frame*", ext), false, false);
708     if (dh < 0) return;
709     int ext_len = strlen(ext);
710     int n = search_getsize(dh);
711     for (int i = 0; i < n; ++i)
712     {
713         string s = search_getfilename(dh, i);
714         s = substring(s, 15, strlen(s) - 15 - ext_len); // strip models/sprites/ and extension
715
716         int o = strstrofs(s, "_frame", 0);
717         string sname = strcat("/spriteframes/", substring(s, 0, o));
718         string sframes = substring(s, o + 6, strlen(s) - o - 6);
719         int f = stof(sframes) + 1;
720         db_put(tempdb, sname, ftos(max(f, stof(db_get(tempdb, sname)))));
721     }
722     search_end(dh);
723 }
724
725 void WaypointSprite_Load();
726 STATIC_INIT(WaypointSprite_Load) {
727     WaypointSprite_Load();
728     WaypointSprite_Load_Frames(".tga");
729     WaypointSprite_Load_Frames(".jpg");
730 }
731 void WaypointSprite_Load()
732 {
733     waypointsprite_fadedistance = vlen(mi_scale);
734     waypointsprite_normdistance = autocvar_g_waypointsprite_normdistance;
735     waypointsprite_minscale = autocvar_g_waypointsprite_minscale;
736     waypointsprite_minalpha = autocvar_g_waypointsprite_minalpha;
737     waypointsprite_distancealphaexponent = autocvar_g_waypointsprite_distancealphaexponent;
738     waypointsprite_timealphaexponent = autocvar_g_waypointsprite_timealphaexponent;
739     waypointsprite_scale = autocvar_g_waypointsprite_scale;
740     waypointsprite_fontsize = autocvar_g_waypointsprite_fontsize;
741     waypointsprite_edgefadealpha = autocvar_g_waypointsprite_edgefadealpha;
742     waypointsprite_edgefadescale = autocvar_g_waypointsprite_edgefadescale;
743     waypointsprite_edgefadedistance = autocvar_g_waypointsprite_edgefadedistance;
744     waypointsprite_edgeoffset_bottom = autocvar_g_waypointsprite_edgeoffset_bottom;
745     waypointsprite_edgeoffset_left = autocvar_g_waypointsprite_edgeoffset_left;
746     waypointsprite_edgeoffset_right = autocvar_g_waypointsprite_edgeoffset_right;
747     waypointsprite_edgeoffset_top = autocvar_g_waypointsprite_edgeoffset_top;
748     waypointsprite_crosshairfadealpha = autocvar_g_waypointsprite_crosshairfadealpha;
749     waypointsprite_crosshairfadescale = autocvar_g_waypointsprite_crosshairfadescale;
750     waypointsprite_crosshairfadedistance = autocvar_g_waypointsprite_crosshairfadedistance;
751     waypointsprite_distancefadealpha = autocvar_g_waypointsprite_distancefadealpha;
752     waypointsprite_distancefadescale = autocvar_g_waypointsprite_distancefadescale;
753     waypointsprite_distancefadedistance = waypointsprite_fadedistance * autocvar_g_waypointsprite_distancefadedistancemultiplier;
754     waypointsprite_alpha = autocvar_g_waypointsprite_alpha * (1 - autocvar__menu_alpha);
755
756     waypointsprite_count = waypointsprite_newcount;
757     waypointsprite_newcount = 0;
758 }
759 #endif
760
761 #ifdef SVQC
762 void WaypointSprite_UpdateSprites(entity e, entity _m1, entity _m2, entity _m3)
763 {
764     string m1 = _m1.netname;
765     string m2 = _m2.netname;
766     string m3 = _m3.netname;
767     if (m1 != e.model1)
768     {
769         e.model1 = m1;
770         e.SendFlags |= 2;
771     }
772     if (m2 != e.model2)
773     {
774         e.model2 = m2;
775         e.SendFlags |= 4;
776     }
777     if (m3 != e.model3)
778     {
779         e.model3 = m3;
780         e.SendFlags |= 8;
781     }
782 }
783
784 void WaypointSprite_UpdateHealth(entity e, float f)
785 {
786     f = bound(0, f, e.max_health);
787     if (f != e.health || e.pain_finished)
788     {
789         e.health = f;
790         e.pain_finished = 0;
791         e.SendFlags |= 0x80;
792     }
793 }
794
795 void WaypointSprite_UpdateMaxHealth(entity e, float f)
796 {
797     if (f != e.max_health || e.pain_finished)
798     {
799         e.max_health = f;
800         e.pain_finished = 0;
801         e.SendFlags |= 0x80;
802     }
803 }
804
805 void WaypointSprite_UpdateBuildFinished(entity e, float f)
806 {
807     if (f != e.pain_finished || e.max_health)
808     {
809         e.max_health = 0;
810         e.pain_finished = f;
811         e.SendFlags |= 0x80;
812     }
813 }
814
815 void WaypointSprite_UpdateOrigin(entity e, vector o)
816 {
817     if (o != e.origin)
818     {
819         setorigin(e, o);
820         e.SendFlags |= 64;
821     }
822 }
823
824 void WaypointSprite_UpdateRule(entity e, float t, float r)
825 {
826     // no check, as this is never called without doing an actual change (usually only once)
827     e.rule = r;
828     e.team = t;
829     e.SendFlags |= 1;
830 }
831
832 void WaypointSprite_UpdateTeamRadar(entity e, entity icon, vector col)
833 {
834     // no check, as this is never called without doing an actual change (usually only once)
835     int i = icon.m_id;
836     e.cnt = (e.cnt & BIT(7)) | (i & BITS(7));
837     e.colormod = col;
838     e.SendFlags |= 32;
839 }
840
841 void WaypointSprite_Ping(entity e)
842 {
843     // anti spam
844     if (time < e.waypointsprite_pingtime) return;
845     e.waypointsprite_pingtime = time + 0.3;
846     // ALWAYS sends (this causes a radar circle), thus no check
847     e.cnt |= BIT(7);
848     e.SendFlags |= 32;
849 }
850
851 void WaypointSprite_HelpMePing(entity e)
852 {
853     WaypointSprite_Ping(e);
854     e.waypointsprite_helpmetime = time + waypointsprite_deployed_lifetime;
855     e.SendFlags |= 32;
856 }
857
858 void WaypointSprite_FadeOutIn(entity e, float t)
859 {
860     if (!e.fade_time)
861     {
862         e.fade_time = t;
863         e.teleport_time = time + t;
864     }
865     else if (t < (e.teleport_time - time))
866     {
867         // accelerate the waypoint's dying
868         // ensure:
869         //   (e.teleport_time - time) / wp.fade_time stays
870         //   e.teleport_time = time + fadetime
871         float current_fadetime;
872         current_fadetime = e.teleport_time - time;
873         e.teleport_time = time + t;
874         e.fade_time = e.fade_time * t / current_fadetime;
875     }
876
877     e.SendFlags |= 16;
878 }
879
880 void WaypointSprite_Init()
881 {
882     waypointsprite_limitedrange = autocvar_sv_waypointsprite_limitedrange;
883     waypointsprite_deployed_lifetime = autocvar_sv_waypointsprite_deployed_lifetime;
884     waypointsprite_deadlifetime = autocvar_sv_waypointsprite_deadlifetime;
885 }
886
887 void WaypointSprite_InitClient(entity e)
888 {
889 }
890
891 void WaypointSprite_Kill(entity wp)
892 {
893     if (!wp) return;
894     if (wp.owner) wp.owner.(wp.owned_by_field) = world;
895     remove(wp);
896 }
897
898 void WaypointSprite_Disown(entity wp, float fadetime)
899 {
900     if (!wp) return;
901     if (wp.classname != "sprite_waypoint")
902     {
903         backtrace("Trying to disown a non-waypointsprite");
904         return;
905     }
906     if (wp.owner)
907     {
908         if (wp.exteriormodeltoclient == wp.owner)
909             wp.exteriormodeltoclient = world;
910         wp.owner.(wp.owned_by_field) = world;
911         wp.owner = world;
912
913         WaypointSprite_FadeOutIn(wp, fadetime);
914     }
915 }
916
917 void WaypointSprite_Think()
918 {SELFPARAM();
919     bool doremove = false;
920
921     if (self.fade_time && time >= self.teleport_time)
922     {
923         doremove = true;
924     }
925
926     if (self.exteriormodeltoclient)
927         WaypointSprite_UpdateOrigin(self, self.exteriormodeltoclient.origin + self.view_ofs);
928
929     if (doremove)
930         WaypointSprite_Kill(self);
931     else
932         self.nextthink = time; // WHY?!?
933 }
934
935 float WaypointSprite_visible_for_player(entity e)
936 {SELFPARAM();
937     // personal waypoints
938     if (self.enemy && self.enemy != e)
939         return false;
940
941     // team waypoints
942     if (self.rule == SPRITERULE_SPECTATOR)
943     {
944         if (!autocvar_sv_itemstime)
945             return false;
946         if (!warmup_stage && IS_PLAYER(e))
947             return false;
948     }
949     else if (self.team && self.rule == SPRITERULE_DEFAULT)
950     {
951         if (self.team != e.team)
952             return false;
953         if (!IS_PLAYER(e))
954             return false;
955     }
956
957     return true;
958 }
959
960 entity WaypointSprite_getviewentity(entity e)
961 {
962     if (IS_SPEC(e)) e = e.enemy;
963     /* TODO idea (check this breaks nothing)
964     else if (e.classname == "observer")
965         e = world;
966     */
967     return e;
968 }
969
970 float WaypointSprite_isteammate(entity e, entity e2)
971 {
972     if (teamplay)
973         return e2.team == e.team;
974     return e2 == e;
975 }
976
977 float WaypointSprite_Customize()
978 {SELFPARAM();
979     // this is not in SendEntity because it shall run every frame, not just every update
980
981     // make spectators see what the player would see
982     entity e = WaypointSprite_getviewentity(other);
983
984     if (MUTATOR_CALLHOOK(CustomizeWaypoint, self, other))
985         return false;
986
987     return self.waypointsprite_visible_for_player(e);
988 }
989
990 bool WaypointSprite_SendEntity(entity this, entity to, float sendflags);
991
992 void WaypointSprite_Reset()
993 {SELFPARAM();
994     // if a WP wants to time out, let it time out immediately; other WPs ought to be reset/killed by their owners
995
996     if (self.fade_time) // there was there before: || g_keyhunt, do we really need this?
997         WaypointSprite_Kill(self);
998 }
999
1000 entity WaypointSprite_Spawn(
1001     entity spr, // sprite
1002     float _lifetime, float maxdistance, // lifetime, max distance
1003     entity ref, vector ofs, // position
1004     entity showto, float t, // show to whom? Use a flag to indicate a team
1005     entity own, .entity ownfield, // remove when own gets killed
1006     float hideable, // true when it should be controlled by cl_hidewaypoints
1007     entity icon // initial icon
1008 )
1009 {
1010     entity wp = new(sprite_waypoint);
1011     wp.teleport_time = time + _lifetime;
1012     wp.fade_time = _lifetime;
1013     wp.exteriormodeltoclient = ref;
1014     if (ref)
1015     {
1016         wp.view_ofs = ofs;
1017         setorigin(wp, ref.origin + ofs);
1018     }
1019     else
1020         setorigin(wp, ofs);
1021     wp.enemy = showto;
1022     wp.team = t;
1023     wp.owner = own;
1024     wp.currentammo = hideable;
1025     if (own)
1026     {
1027         if (own.(ownfield))
1028             remove(own.(ownfield));
1029         own.(ownfield) = wp;
1030         wp.owned_by_field = ownfield;
1031     }
1032     wp.fade_rate = maxdistance;
1033     wp.think = WaypointSprite_Think;
1034     wp.nextthink = time;
1035     wp.model1 = spr.netname;
1036     wp.customizeentityforclient = WaypointSprite_Customize;
1037     wp.waypointsprite_visible_for_player = WaypointSprite_visible_for_player;
1038     wp.reset2 = WaypointSprite_Reset;
1039     wp.cnt = icon.m_id;
1040     wp.colormod = spr.m_color;
1041     Net_LinkEntity(wp, false, 0, WaypointSprite_SendEntity);
1042     return wp;
1043 }
1044
1045 entity WaypointSprite_SpawnFixed(
1046     entity spr,
1047     vector ofs,
1048     entity own,
1049     .entity ownfield,
1050     entity icon // initial icon
1051 )
1052 {
1053     return WaypointSprite_Spawn(spr, 0, 0, world, ofs, world, 0, own, ownfield, true, icon);
1054 }
1055
1056 entity WaypointSprite_DeployFixed(
1057     entity spr,
1058     float limited_range,
1059     vector ofs,
1060     entity icon // initial icon
1061 )
1062 {SELFPARAM();
1063     float t;
1064     if (teamplay)
1065         t = self.team;
1066     else
1067         t = 0;
1068     float maxdistance;
1069     if (limited_range)
1070         maxdistance = waypointsprite_limitedrange;
1071     else
1072         maxdistance = 0;
1073     return WaypointSprite_Spawn(spr, waypointsprite_deployed_lifetime, maxdistance, world, ofs, world, t, self, waypointsprite_deployed_fixed, false, icon);
1074 }
1075
1076 entity WaypointSprite_DeployPersonal(
1077     entity spr,
1078     vector ofs,
1079     entity icon // initial icon
1080 )
1081 {SELFPARAM();
1082     return WaypointSprite_Spawn(spr, 0, 0, world, ofs, world, 0, self, waypointsprite_deployed_personal, false, icon);
1083 }
1084
1085 entity WaypointSprite_Attach(
1086     entity spr,
1087     float limited_range,
1088     entity icon // initial icon
1089 )
1090 {SELFPARAM();
1091     float t;
1092     if (self.waypointsprite_attachedforcarrier)
1093         return world; // can't attach to FC
1094     if (teamplay)
1095         t = self.team;
1096     else
1097         t = 0;
1098     float maxdistance;
1099     if (limited_range)
1100         maxdistance = waypointsprite_limitedrange;
1101     else
1102         maxdistance = 0;
1103     return WaypointSprite_Spawn(spr, waypointsprite_deployed_lifetime, maxdistance, self, '0 0 64', world, t, self, waypointsprite_attached, false, icon);
1104 }
1105
1106 entity WaypointSprite_AttachCarrier(
1107     entity spr,
1108     entity carrier,
1109     entity icon // initial icon and color
1110 )
1111 {
1112     WaypointSprite_Kill(carrier.waypointsprite_attached); // FC overrides attached
1113     entity e = WaypointSprite_Spawn(spr, 0, 0, carrier, '0 0 64', world, carrier.team, carrier, waypointsprite_attachedforcarrier, false, icon);
1114     if (e)
1115     {
1116         WaypointSprite_UpdateMaxHealth(e, '1 0 0' * healtharmor_maxdamage(start_health, start_armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id) * 2);
1117         WaypointSprite_UpdateHealth(e, '1 0 0' * healtharmor_maxdamage(carrier.health, carrier.armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id));
1118     }
1119     return e;
1120 }
1121
1122 void WaypointSprite_DetachCarrier(entity carrier)
1123 {
1124     WaypointSprite_Disown(carrier.waypointsprite_attachedforcarrier, waypointsprite_deadlifetime);
1125 }
1126
1127 void WaypointSprite_ClearPersonal()
1128 {SELFPARAM();
1129     WaypointSprite_Kill(self.waypointsprite_deployed_personal);
1130 }
1131
1132 void WaypointSprite_ClearOwned()
1133 {SELFPARAM();
1134     WaypointSprite_Kill(self.waypointsprite_deployed_fixed);
1135     WaypointSprite_Kill(self.waypointsprite_deployed_personal);
1136     WaypointSprite_Kill(self.waypointsprite_attached);
1137 }
1138
1139 void WaypointSprite_PlayerDead()
1140 {SELFPARAM();
1141     WaypointSprite_Disown(self.waypointsprite_attached, waypointsprite_deadlifetime);
1142     WaypointSprite_DetachCarrier(self);
1143 }
1144
1145 void WaypointSprite_PlayerGone()
1146 {SELFPARAM();
1147     WaypointSprite_Disown(self.waypointsprite_deployed_fixed, waypointsprite_deadlifetime);
1148     WaypointSprite_Kill(self.waypointsprite_deployed_personal);
1149     WaypointSprite_Disown(self.waypointsprite_attached, waypointsprite_deadlifetime);
1150     WaypointSprite_DetachCarrier(self);
1151 }
1152 #endif
1153 #endif