68ecfd74b022f2dc77f04afdad869c02cd1f644d
[xonotic/xonotic-data.pk3dir.git] / qcsrc / client / waypointsprites.qc
1 float waypointsprite_initialized;
2 float waypointsprite_fadedistance;
3 float waypointsprite_normdistance;
4 float waypointsprite_minscale;
5 float waypointsprite_minalpha;
6 float waypointsprite_distancealphaexponent;
7 float waypointsprite_timealphaexponent;
8 float waypointsprite_scale;
9 float waypointsprite_fontsize;
10 float waypointsprite_edgefadealpha;
11 float waypointsprite_edgefadescale;
12 float waypointsprite_edgefadedistance;
13 float waypointsprite_edgeoffset_bottom;
14 float waypointsprite_edgeoffset_left;
15 float waypointsprite_edgeoffset_right;
16 float waypointsprite_edgeoffset_top;
17 float waypointsprite_crosshairfadealpha;
18 float waypointsprite_crosshairfadescale;
19 float waypointsprite_crosshairfadedistance;
20 float waypointsprite_distancefadealpha;
21 float waypointsprite_distancefadescale;
22 float waypointsprite_distancefadedistance;
23 float waypointsprite_alpha;
24
25 .float helpme;
26 .float rule;
27 .string netname; // primary picture
28 .string netname2; // secondary picture
29 .string netname3; // tertiary picture
30 .float team; // team that gets netname2
31 .float lifetime;
32 .float fadetime;
33 .float maxdistance;
34 .float hideflags;
35 .float spawntime;
36 .float health;
37 .float build_started;
38 .float build_starthealth;
39 .float build_finished;
40
41 const float SPRITE_HEALTHBAR_WIDTH = 144;
42 const float SPRITE_HEALTHBAR_HEIGHT = 9;
43 const float SPRITE_HEALTHBAR_MARGIN = 6;
44 const float SPRITE_HEALTHBAR_BORDER = 2;
45 const float SPRITE_HEALTHBAR_BORDERALPHA = 1;
46 const float SPRITE_HEALTHBAR_HEALTHALPHA = 0.5;
47 const float SPRITE_ARROW_SCALE = 1.0;
48 const float SPRITE_HELPME_BLINK = 2;
49
50 void drawrotpic(vector org, float rot, string pic, vector sz, vector hotspot, vector rgb, float a, float f)
51 {
52         vector v1, v2, v3, v4;
53
54         hotspot = -1 * hotspot;
55
56         // hotspot-relative coordinates of the corners
57         v1 = hotspot;
58         v2 = hotspot + '1 0 0' * sz_x;
59         v3 = hotspot + '1 0 0' * sz_x + '0 1 0' * sz_y;
60         v4 = hotspot                  + '0 1 0' * sz_y;
61
62         // rotate them, and make them absolute
63         rot = -rot; // rotate by the opposite angle, as our coordinate system is reversed
64         v1 = rotate(v1, rot) + org;
65         v2 = rotate(v2, rot) + org;
66         v3 = rotate(v3, rot) + org;
67         v4 = rotate(v4, rot) + org;
68
69         // draw them
70         R_BeginPolygon(pic, f);
71         R_PolygonVertex(v1, '0 0 0', rgb, a);
72         R_PolygonVertex(v2, '1 0 0', rgb, a);
73         R_PolygonVertex(v3, '1 1 0', rgb, a);
74         R_PolygonVertex(v4, '0 1 0', rgb, a);
75         R_EndPolygon();
76 }
77
78 void drawquad(vector o, vector ri, vector up, string pic, vector rgb, float a, float f)
79 {
80         R_BeginPolygon(pic, f);
81         R_PolygonVertex(o, '0 0 0', rgb, a);
82         R_PolygonVertex(o + ri, '1 0 0', rgb, a);
83         R_PolygonVertex(o + up + ri, '1 1 0', rgb, a);
84         R_PolygonVertex(o + up, '0 1 0', rgb, a);
85         R_EndPolygon();
86 }
87
88 void drawhealthbar(vector org, float rot, float h, vector sz, vector hotspot, float width, float height, float margin, float border, float align, vector rgb, float a, vector hrgb, float ha, float f)
89 {
90         vector o, ri, up;
91         float owidth; // outer width
92
93         hotspot = -1 * hotspot;
94
95         // hotspot-relative coordinates of the healthbar corners
96         o = hotspot;
97         ri = '1 0 0';
98         up = '0 1 0';
99
100         rot = -rot; // rotate by the opposite angle, as our coordinate system is reversed
101         o = rotate(o, rot) + org;
102         ri = rotate(ri, rot);
103         up = rotate(up, rot);
104
105         owidth = width + 2 * border;
106         o = o - up * (margin + border + height) + ri * (sz_x - owidth) * 0.5;
107
108         drawquad(o - up * border,                               ri * owidth,    up * border, "", rgb,  a,  f);
109         drawquad(o + up * height,                               ri * owidth,    up * border, "", rgb,  a,  f);
110         drawquad(o,                                             ri * border,    up * height, "", rgb,  a,  f);
111         drawquad(o + ri * (owidth - border),                    ri * border,    up * height, "", rgb,  a,  f);
112         drawquad(o + ri * (border + align * ((1 - h) * width)), ri * width * h, up * height, "", hrgb, ha, f);
113 }
114
115 // returns location of sprite text
116 vector drawspritearrow(vector o, float ang, vector rgb, float a, float t)
117 {
118         float size   = 9.0 * t;
119         float border = 1.5 * t;
120         float margin = 4.0 * t;
121
122         float borderDiag = border * 1.414;
123         vector arrowX  = eX * size;
124         vector arrowY  = eY * (size+borderDiag);
125         vector borderX = eX * (size+borderDiag);
126         vector borderY = eY * (size+borderDiag+border);
127
128         R_BeginPolygon("", DRAWFLAG_NORMAL);
129         R_PolygonVertex(o,                                  '0 0 0', '0 0 0', a);
130         R_PolygonVertex(o + rotate(arrowY  - borderX, ang), '0 0 0', '0 0 0', a);
131         R_PolygonVertex(o + rotate(borderY - borderX, ang), '0 0 0', '0 0 0', a);
132         R_PolygonVertex(o + rotate(borderY + borderX, ang), '0 0 0', '0 0 0', a);
133         R_PolygonVertex(o + rotate(arrowY  + borderX, ang), '0 0 0', '0 0 0', a);
134         R_EndPolygon();
135
136         R_BeginPolygon("", DRAWFLAG_ADDITIVE);
137         R_PolygonVertex(o + rotate(eY * borderDiag, ang), '0 0 0', rgb, a);
138         R_PolygonVertex(o + rotate(arrowY - arrowX, ang), '0 0 0', rgb, a);
139         R_PolygonVertex(o + rotate(arrowY + arrowX, ang), '0 0 0', rgb, a);
140         R_EndPolygon();
141
142         return o + rotate(eY * (borderDiag+size+margin), ang);
143 }
144
145 // returns location of sprite healthbar
146 vector drawspritetext(vector o, float ang, float minwidth, vector rgb, float a, vector fontsize, string s)
147 {
148         float algnx, algny;
149         float sw, w, h;
150         float aspect, sa, ca;
151
152         sw = stringwidth(s, FALSE, fontsize);
153         if(sw > minwidth)
154                 w = sw;
155         else
156                 w = minwidth;
157         h = fontsize_y;
158
159         // how do corners work?
160         aspect = vid_conwidth / vid_conheight;
161         sa = sin(ang);
162         ca = cos(ang) * aspect;
163         if(fabs(sa) > fabs(ca))
164         {
165                 algnx = (sa < 0);
166                 algny = 0.5 - 0.5 * ca / fabs(sa);
167         }
168         else
169         {
170                 algnx = 0.5 - 0.5 * sa / fabs(ca);
171                 algny = (ca < 0);
172         }
173
174         // align
175         o_x -= w * algnx;
176         o_y -= h * algny;
177
178         // we want to be onscreen
179         if(o_x < 0)
180                 o_x = 0;
181         if(o_y < 0)
182                 o_y = 0;
183         if(o_x > vid_conwidth - w)
184                 o_x = vid_conwidth - w;
185         if(o_y > vid_conheight - h)
186                 o_x = vid_conheight - h;
187
188         o_x += 0.5 * (w - sw);
189
190         drawstring(o, s, fontsize, rgb, a, DRAWFLAG_NORMAL);
191
192         o_x += 0.5 * sw;
193         o_y += 0.5 * h;
194
195         return o;
196 }
197
198 float spritelookupblinkvalue(string s)
199 {
200         switch(s)
201         {
202                 case "ons-cp-atck-neut": return 2;
203                 case "ons-cp-atck-red":  return 2;
204                 case "ons-cp-atck-blue": return 2;
205                 case "ons-cp-dfnd-red":  return 0.5;
206                 case "ons-cp-dfnd-blue": return 0.5;
207                 case "item-invis":       return 2;
208                 case "item-extralife":   return 2;
209                 case "item-speed":       return 2;
210                 case "item-strength":    return 2;
211                 case "item-shield":      return 2;
212                 case "item-fuelregen":   return 2;
213                 case "item-jetpack":     return 2;
214                 case "tagged-target":    return 2;
215                 default:                 return 1;
216         }
217 }
218 vector spritelookupcolor(string s, vector def)
219 {
220         if(substring(s, 0, 4) == "wpn-")
221                 return (get_weaponinfo(stof(substring(s, 4, strlen(s)))).wpcolor);
222
223         switch(s)
224         {
225                 case "keycarrier-friend": return '0 1 0';
226                 default:                  return def;
227         }
228 }
229 string spritelookuptext(string s)
230 {
231         if(substring(s, 0, 4) == "wpn-")
232                 return (get_weaponinfo(stof(substring(s, 4, strlen(s)))).message);
233
234         switch(s)
235         {
236                 case "as-push": return _("Push");
237                 case "as-destroy": return _("Destroy");
238                 case "as-defend": return _("Defend");
239                 case "bluebase": return _("Blue base");
240                 case "danger": return _("DANGER");
241                 case "enemyflagcarrier": return _("Enemy carrier");
242                 case "flagcarrier": return _("Flag carrier");
243                 case "flagdropped": return _("Dropped flag");
244                 case "helpme": return _("Help me!");
245                 case "here": return _("Here");
246                 case "key-dropped": return _("Dropped key");
247                 case "keycarrier-blue": return _("Key carrier");
248                 case "keycarrier-finish": return _("Run here");
249                 case "keycarrier-friend": return _("Key carrier");
250                 case "keycarrier-pink": return _("Key carrier");
251                 case "keycarrier-red": return _("Key carrier");
252                 case "keycarrier-yellow": return _("Key carrier");
253                 case "redbase": return _("Red base");
254                 case "waypoint": return _("Waypoint");
255                 case "ons-gen-red": return _("Generator");
256                 case "ons-gen-blue": return _("Generator");
257                 case "ons-gen-shielded": return _("Generator");
258                 case "ons-cp-neut": return _("Control point");
259                 case "ons-cp-red": return _("Control point");
260                 case "ons-cp-blue": return _("Control point");
261                 case "ons-cp-atck-neut": return _("Control point");
262                 case "ons-cp-atck-red": return _("Control point");
263                 case "ons-cp-atck-blue": return _("Control point");
264                 case "ons-cp-dfnd-red": return _("Control point");
265                 case "ons-cp-dfnd-blue": return _("Control point");
266                 case "race-checkpoint": return _("Checkpoint");
267                 case "race-finish": return _("Finish");
268                 case "race-start": return _("Start");
269                 case "race-start-finish": return (race_checkpointtime || race_mycheckpointtime) ? _("Finish") : _("Start");
270                 case "nb-ball": return _("Ball");
271                 case "ka-ball": return _("Ball");
272                 case "ka-ballcarrier": return _("Ball carrier");
273                 case "dom-neut": return _("Control point");
274                 case "dom-red": return _("Control point");
275                 case "dom-blue": return _("Control point");
276                 case "dom-yellow": return _("Control point");
277                 case "dom-pink": return _("Control point");
278                 case "item-invis": return _("Invisibility");
279                 case "item-extralife": return _("Extra life");
280                 case "item-speed": return _("Speed");
281                 case "item-strength": return _("Strength");
282                 case "item-shield": return _("Shield");
283                 case "item-fuelregen": return _("Fuel regen");
284                 case "item-jetpack": return _("Jet Pack");
285                 case "freezetag_frozen": return _("Frozen!");
286                 case "tagged-target": return _("Tagged");
287                 case "vehicle": return _("Vehicle");
288                 default: return s;
289         }
290 }
291
292 vector fixrgbexcess_move(vector rgb, vector src, vector dst)
293 {
294         vector yvec = '0.299 0.587 0.114';
295         return rgb + dst * ((src * yvec) / (dst * yvec)) * ((rgb - '1 1 1') * src);
296 }
297 vector fixrgbexcess(vector rgb)
298 {
299         if(rgb_x > 1)
300         {
301                 rgb = fixrgbexcess_move(rgb, '1 0 0', '0 1 1');
302                 if(rgb_y > 1)
303                 {
304                         rgb = fixrgbexcess_move(rgb, '0 1 0', '0 0 1');
305                         if(rgb_z > 1)
306                                 rgb_z = 1;
307                 }
308                 else if(rgb_z > 1)
309                 {
310                         rgb = fixrgbexcess_move(rgb, '0 0 1', '0 1 0');
311                         if(rgb_y > 1)
312                                 rgb_y = 1;
313                 }
314         }
315         else if(rgb_y > 1)
316         {
317                 rgb = fixrgbexcess_move(rgb, '0 1 0', '1 0 1');
318                 if(rgb_x > 1)
319                 {
320                         rgb = fixrgbexcess_move(rgb, '1 0 0', '0 0 1');
321                         if(rgb_z > 1)
322                                 rgb_z = 1;
323                 }
324                 else if(rgb_z > 1)
325                 {
326                         rgb = fixrgbexcess_move(rgb, '0 0 1', '1 0 0');
327                         if(rgb_x > 1)
328                                 rgb_x = 1;
329                 }
330         }
331         else if(rgb_z > 1)
332         {
333                 rgb = fixrgbexcess_move(rgb, '0 0 1', '1 1 0');
334                 if(rgb_x > 1)
335                 {
336                         rgb = fixrgbexcess_move(rgb, '1 0 0', '0 1 0');
337                         if(rgb_y > 1)
338                                 rgb_y = 1;
339                 }
340                 else if(rgb_y > 1)
341                 {
342                         rgb = fixrgbexcess_move(rgb, '0 1 0', '1 0 0');
343                         if(rgb_x > 1)
344                                 rgb_x = 1;
345                 }
346         }
347         return rgb;
348 }
349
350 float waypointsprite_count, waypointsprite_newcount;
351 void Draw_WaypointSprite()
352 {
353         string spriteimage;
354         float t;
355
356         if(self.lifetime)
357                 self.alpha = pow(bound(0, (self.fadetime - time) / self.lifetime, 1), waypointsprite_timealphaexponent);
358         else
359                 self.alpha = 1;
360
361         if(self.hideflags & 2)
362                 return; // radar only
363
364         if(autocvar_cl_hidewaypoints >= 2)
365                 return;
366
367         if(self.hideflags & 1)
368                 if(autocvar_cl_hidewaypoints)
369                         return; // fixed waypoint
370
371         InterpolateOrigin_Do();
372
373         t = GetPlayerColor(player_localnum) + 1;
374
375         spriteimage = "";
376
377         // choose the sprite
378         switch(self.rule)
379         {
380                 case SPRITERULE_DEFAULT:
381                         if(self.team)
382                         {
383                                 if(self.team == t)
384                                         spriteimage = self.netname;
385                                 else
386                                         spriteimage = "";
387                         }
388                         else
389                                 spriteimage = self.netname;
390                         break;
391                 case SPRITERULE_TEAMPLAY:
392                         if(t == NUM_SPECTATOR + 1)
393                                 spriteimage = self.netname3;
394                         else if(self.team == t)
395                                 spriteimage = self.netname2;
396                         else
397                                 spriteimage = self.netname;
398                         break;
399                 default:
400                         error("Invalid waypointsprite rule!");
401                         break;
402         }
403
404         if(spriteimage == "")
405                 return;
406
407         ++waypointsprite_newcount;
408
409         float dist;
410         dist = vlen(self.origin - view_origin);
411
412         float a;
413         a = self.alpha * autocvar_hud_panel_fg_alpha;
414
415         if(self.maxdistance > waypointsprite_normdistance)
416                 a *= pow(bound(0, (self.maxdistance - dist) / (self.maxdistance - waypointsprite_normdistance), 1), waypointsprite_distancealphaexponent);
417         else if(self.maxdistance > 0)
418                 a *= pow(bound(0, (waypointsprite_fadedistance - dist) / (waypointsprite_fadedistance - waypointsprite_normdistance), 1), waypointsprite_distancealphaexponent) * (1 - waypointsprite_minalpha) + waypointsprite_minalpha;
419
420         vector rgb;
421         rgb = self.teamradar_color;
422         rgb = spritelookupcolor(spriteimage, rgb);
423         if(rgb == '0 0 0')
424         {
425                 self.teamradar_color = '1 0 1';
426                 printf("WARNING: sprite of name %s has no color, using pink so you notice it\n", spriteimage);
427         }
428
429         if(time - floor(time) > 0.5)
430         {
431                 if(self.helpme && time < self.helpme)
432                         a *= SPRITE_HELPME_BLINK;
433                 else
434                         a *= spritelookupblinkvalue(spriteimage);
435         }
436
437         if(a > 1)
438         {
439                 rgb *= a;
440                 a = 1;
441         }
442
443         if(a <= 0)
444                 return;
445
446         rgb = fixrgbexcess(rgb);
447
448         vector o;
449         float ang;
450
451         o = project_3d_to_2d(self.origin);
452         if(o_z < 0
453         || o_x < (vid_conwidth * waypointsprite_edgeoffset_left)
454         || o_y < (vid_conheight * waypointsprite_edgeoffset_top)
455         || o_x > (vid_conwidth - (vid_conwidth * waypointsprite_edgeoffset_right))
456         || o_y > (vid_conheight - (vid_conheight * waypointsprite_edgeoffset_bottom)))
457         {
458                 // scale it to be just in view
459                 vector d;
460                 float f1, f2;
461
462                 d = o - '0.5 0 0' * vid_conwidth - '0 0.5 0' * vid_conheight;
463                 ang = atan2(-d_x, -d_y);
464                 if(o_z < 0)
465                         ang += M_PI;
466
467                 f1 = d_x / vid_conwidth;
468                 f2 = d_y / vid_conheight;
469
470                 if(max(f1, -f1) > max(f2, -f2))
471                 {
472                         if(d_z * f1 > 0)
473                         {
474                                 // RIGHT edge
475                                 d = d * ((0.5 - waypointsprite_edgeoffset_right) / f1);
476                         }
477                         else
478                         {
479                                 // LEFT edge
480                                 d = d * (-(0.5 - waypointsprite_edgeoffset_left) / f1);
481                         }
482                 }
483                 else
484                 {
485                         if(d_z * f2 > 0)
486                         {
487                                 // BOTTOM edge
488                                 d = d * ((0.5 - waypointsprite_edgeoffset_bottom) / f2);
489                         }
490                         else
491                         {
492                                 // TOP edge
493                                 d = d * (-(0.5 - waypointsprite_edgeoffset_top) / f2);
494                         }
495                 }
496
497                 o = d + '0.5 0 0' * vid_conwidth + '0 0.5 0' * vid_conheight;
498         }
499         else
500         {
501 #if 1
502                 ang = M_PI;
503 #else
504                 vector d;
505                 d = o - '0.5 0 0' * vid_conwidth - '0 0.5 0' * vid_conheight;
506                 ang = atan2(-d_x, -d_y);
507 #endif
508         }
509         o_z = 0;
510
511         float edgedistance_min, crosshairdistance;
512                 edgedistance_min = min((o_y - (vid_conheight * waypointsprite_edgeoffset_top)),
513         (o_x - (vid_conwidth * waypointsprite_edgeoffset_left)),
514         (vid_conwidth - (vid_conwidth * waypointsprite_edgeoffset_right)) - o_x,
515         (vid_conheight - (vid_conheight * waypointsprite_edgeoffset_bottom)) - o_y);
516
517         float vidscale;
518         vidscale = max(vid_conwidth / vid_width, vid_conheight / vid_height);
519
520         crosshairdistance = sqrt( pow(o_x - vid_conwidth/2, 2) + pow(o_y - vid_conheight/2, 2) );
521
522         t = waypointsprite_scale * vidscale;
523         a *= waypointsprite_alpha;
524
525         {
526                 a = a * (1 - (1 - waypointsprite_distancefadealpha) * (bound(0, dist/waypointsprite_distancefadedistance, 1)));
527                 t = t * (1 - (1 - waypointsprite_distancefadescale) * (bound(0, dist/waypointsprite_distancefadedistance, 1)));
528         }
529         if (edgedistance_min < waypointsprite_edgefadedistance) {
530                 a = a * (1 - (1 - waypointsprite_edgefadealpha) * (1 - bound(0, edgedistance_min/waypointsprite_edgefadedistance, 1)));
531                 t = t * (1 - (1 - waypointsprite_edgefadescale) * (1 - bound(0, edgedistance_min/waypointsprite_edgefadedistance, 1)));
532         }
533         if(crosshairdistance < waypointsprite_crosshairfadedistance) {
534                 a = a * (1 - (1 - waypointsprite_crosshairfadealpha) * (1 - bound(0, crosshairdistance/waypointsprite_crosshairfadedistance, 1)));
535                 t = t * (1 - (1 - waypointsprite_crosshairfadescale) * (1 - bound(0, crosshairdistance/waypointsprite_crosshairfadedistance, 1)));
536         }
537
538         if(self.build_finished)
539         {
540                 if(time < self.build_finished + 0.25)
541                 {
542                         if(time < self.build_started)
543                                 self.health = self.build_starthealth;
544                         else if(time < self.build_finished)
545                                 self.health = (time - self.build_started) / (self.build_finished - self.build_started) * (1 - self.build_starthealth) + self.build_starthealth;
546                         else
547                                 self.health = 1;
548                 }
549                 else
550                         self.health = -1;
551         }
552
553         o = drawspritearrow(o, ang, rgb, a, SPRITE_ARROW_SCALE * t);
554
555         string txt;
556         if(autocvar_g_waypointsprite_spam && waypointsprite_count >= autocvar_g_waypointsprite_spam)
557                 txt = _("Spam");
558         else
559                 txt = spritelookuptext(spriteimage);
560         if(self.helpme && time < self.helpme)
561                 txt = sprintf(_("%s needing help!"), txt);
562         if(autocvar_g_waypointsprite_uppercase)
563                 txt = strtoupper(txt);
564
565         draw_beginBoldFont();
566         if(self.health >= 0)
567         {
568                 o = drawspritetext(o, ang, (SPRITE_HEALTHBAR_WIDTH + 2 * SPRITE_HEALTHBAR_BORDER) * t, rgb, a, waypointsprite_fontsize * '1 1 0', txt);
569
570                 float align, marg;
571                 if(self.build_finished)
572                         align = 0.5;
573                 else
574                         align = 0;
575                 if(cos(ang) > 0)
576                         marg = -(SPRITE_HEALTHBAR_MARGIN + SPRITE_HEALTHBAR_HEIGHT + 2 * SPRITE_HEALTHBAR_BORDER) * t - 0.5 * waypointsprite_fontsize;
577                 else
578                         marg = SPRITE_HEALTHBAR_MARGIN * t + 0.5 * waypointsprite_fontsize;
579                 drawhealthbar(
580                                 o,
581                                 0,
582                                 self.health,
583                                 '0 0 0',
584                                 '0 0 0',
585                                 SPRITE_HEALTHBAR_WIDTH * t,
586                                 SPRITE_HEALTHBAR_HEIGHT * t,
587                                 marg,
588                                 SPRITE_HEALTHBAR_BORDER * t,
589                                 align,
590                                 rgb,
591                                 a * SPRITE_HEALTHBAR_BORDERALPHA,
592                                 rgb,
593                                 a * SPRITE_HEALTHBAR_HEALTHALPHA,
594                                 DRAWFLAG_NORMAL
595                              );
596         }
597         else
598         {
599                 o = drawspritetext(o, ang, 0, rgb, a, waypointsprite_fontsize * '1 1 0', txt);
600         }
601         draw_endBoldFont();
602 }
603
604 void Ent_RemoveWaypointSprite()
605 {
606         if(self.netname)
607                 strunzone(self.netname);
608         if(self.netname2)
609                 strunzone(self.netname2);
610         if(self.netname3)
611                 strunzone(self.netname3);
612 }
613
614 void Ent_WaypointSprite()
615 {
616         float sendflags, f, t;
617         sendflags = ReadByte();
618
619         if(!self.spawntime)
620                 self.spawntime = time;
621
622         self.draw2d = Draw_WaypointSprite;
623
624         InterpolateOrigin_Undo();
625         self.iflags |= IFLAG_ORIGIN;
626
627         if(sendflags & 0x80)
628         {
629                 t = ReadByte();
630                 if(t < 192)
631                 {
632                         self.health = t / 191.0;
633                         self.build_finished = 0;
634                 }
635                 else
636                 {
637                         t = (t - 192) * 256 + ReadByte();
638                         self.build_started = servertime;
639                         if(self.build_finished)
640                                 self.build_starthealth = bound(0, self.health, 1);
641                         else
642                                 self.build_starthealth = 0;
643                         self.build_finished = servertime + t / 32;
644                 }
645         }
646         else
647         {
648                 self.health = -1;
649                 self.build_finished = 0;
650         }
651
652         if(sendflags & 64)
653         {
654                 // unfortunately, this needs to be exact (for the 3D display)
655                 self.origin_x = ReadCoord();
656                 self.origin_y = ReadCoord();
657                 self.origin_z = ReadCoord();
658                 setorigin(self, self.origin);
659         }
660
661         if(sendflags & 1)
662         {
663                 self.team = ReadByte();
664                 self.rule = ReadByte();
665         }
666
667         if(sendflags & 2)
668         {
669                 if(self.netname)
670                         strunzone(self.netname);
671                 self.netname = strzone(ReadString());
672         }
673
674         if(sendflags & 4)
675         {
676                 if(self.netname2)
677                         strunzone(self.netname2);
678                 self.netname2 = strzone(ReadString());
679         }
680
681         if(sendflags & 8)
682         {
683                 if(self.netname3)
684                         strunzone(self.netname3);
685                 self.netname3 = strzone(ReadString());
686         }
687
688         if(sendflags & 16)
689         {
690                 self.lifetime = ReadCoord();
691                 self.fadetime = ReadCoord();
692                 self.maxdistance = ReadShort();
693                 self.hideflags = ReadByte();
694         }
695
696         if(sendflags & 32)
697         {
698                 f = ReadByte();
699                 self.teamradar_icon = (f & 0x7F);
700                 if(f & 0x80)
701                 {
702                         self.(teamradar_times[self.teamradar_time_index]) = time;
703                         self.teamradar_time_index = mod(self.teamradar_time_index + 1, MAX_TEAMRADAR_TIMES);
704                 }
705                 self.teamradar_color_x = ReadByte() / 255.0;
706                 self.teamradar_color_y = ReadByte() / 255.0;
707                 self.teamradar_color_z = ReadByte() / 255.0;
708                 self.helpme = ReadByte() * 0.1;
709                 if(self.helpme > 0)
710                         self.helpme += servertime;
711         }
712
713         InterpolateOrigin_Note();
714
715         self.entremove = Ent_RemoveWaypointSprite;
716 }
717
718 void WaypointSprite_Load_Frames(string ext)
719 {
720         float dh, n, i, o, f;
721         string s, sname, sframes;
722         dh = search_begin(strcat("models/sprites/*_frame*", ext), FALSE, FALSE);
723         if (dh < 0)
724                  return;
725         float ext_len = strlen(ext);
726         n = search_getsize(dh);
727         for(i = 0; i < n; ++i)
728         {
729                 s = search_getfilename(dh, i);
730                 s = substring(s, 15, strlen(s) - 15 - ext_len); // strip models/sprites/ and extension
731
732                 o = strstrofs(s, "_frame", 0);
733                 sname = strcat("/spriteframes/", substring(s, 0, o));
734                 sframes = substring(s, o + 6, strlen(s) - o - 6);
735                 f = stof(sframes) + 1;
736                 db_put(tempdb, sname, ftos(max(f, stof(db_get(tempdb, sname)))));
737         }
738         search_end(dh);
739 }
740
741 void WaypointSprite_Load()
742 {
743         waypointsprite_fadedistance = vlen(mi_scale);
744         waypointsprite_normdistance = autocvar_g_waypointsprite_normdistance;
745         waypointsprite_minscale = autocvar_g_waypointsprite_minscale;
746         waypointsprite_minalpha = autocvar_g_waypointsprite_minalpha;
747         waypointsprite_distancealphaexponent = autocvar_g_waypointsprite_distancealphaexponent;
748         waypointsprite_timealphaexponent = autocvar_g_waypointsprite_timealphaexponent;
749         waypointsprite_scale = autocvar_g_waypointsprite_scale;
750         waypointsprite_fontsize = autocvar_g_waypointsprite_fontsize;
751         waypointsprite_edgefadealpha = autocvar_g_waypointsprite_edgefadealpha;
752         waypointsprite_edgefadescale = autocvar_g_waypointsprite_edgefadescale;
753         waypointsprite_edgefadedistance = autocvar_g_waypointsprite_edgefadedistance;
754         waypointsprite_edgeoffset_bottom = autocvar_g_waypointsprite_edgeoffset_bottom;
755         waypointsprite_edgeoffset_left = autocvar_g_waypointsprite_edgeoffset_left;
756         waypointsprite_edgeoffset_right = autocvar_g_waypointsprite_edgeoffset_right;
757         waypointsprite_edgeoffset_top = autocvar_g_waypointsprite_edgeoffset_top;
758         waypointsprite_crosshairfadealpha = autocvar_g_waypointsprite_crosshairfadealpha;
759         waypointsprite_crosshairfadescale = autocvar_g_waypointsprite_crosshairfadescale;
760         waypointsprite_crosshairfadedistance = autocvar_g_waypointsprite_crosshairfadedistance;
761         waypointsprite_distancefadealpha = autocvar_g_waypointsprite_distancefadealpha;
762         waypointsprite_distancefadescale = autocvar_g_waypointsprite_distancefadescale;
763         waypointsprite_distancefadedistance = waypointsprite_fadedistance * autocvar_g_waypointsprite_distancefadedistancemultiplier;
764         waypointsprite_alpha = autocvar_g_waypointsprite_alpha * (1 - autocvar__menu_alpha);
765
766         if(!waypointsprite_initialized)
767         {
768                 WaypointSprite_Load_Frames(".tga");
769                 WaypointSprite_Load_Frames(".jpg");
770                 waypointsprite_initialized = true;
771         }
772
773         waypointsprite_count = waypointsprite_newcount;
774         waypointsprite_newcount = 0;
775 }