Merge branch 'master' into sev/luma_revisions
[xonotic/xonotic-data.pk3dir.git] / qcsrc / client / hud.qc
1 #include "hud.qh"
2 #include "_all.qh"
3
4 #include "hud_config.qh"
5 #include "scoreboard.qh"
6 #include "sortlist.qh"
7 #include "teamradar.qh"
8 #include "t_items.qh"
9
10 #include "../common/buffs.qh"
11 #include "../common/constants.qh"
12 #include "../common/counting.qh"
13 #include "../common/deathtypes.qh"
14 #include "../common/mapinfo.qh"
15 #include "../common/nades.qh"
16 #include "../common/stats.qh"
17
18 #include "../csqcmodellib/cl_player.qh"
19
20 #include "../warpzonelib/mathlib.qh"
21
22 /*
23 ==================
24 Misc HUD functions
25 ==================
26 */
27
28 // a border picture is a texture containing nine parts:
29 //   1/4 width: left part
30 //   1/2 width: middle part (stretched)
31 //   1/4 width: right part
32 // divided into
33 //   1/4 height: top part
34 //   1/2 height: middle part (stretched)
35 //   1/4 height: bottom part
36 void draw_BorderPicture(vector theOrigin, string pic, vector theSize, vector theColor, float theAlpha, vector theBorderSize)
37 {
38     if (theBorderSize.x < 0 && theBorderSize.y < 0) // draw whole image as it is
39     {
40                 drawpic(theOrigin, pic, theSize, theColor, theAlpha, 0);
41                 return;
42     }
43         if (theBorderSize.x == 0 && theBorderSize.y == 0) // no border
44         {
45                 // draw only the central part
46                 drawsubpic(theOrigin, theSize, pic, '0.25 0.25 0', '0.5 0.5 0', theColor, theAlpha, 0);
47                 return;
48         }
49
50         vector dX, dY;
51         vector width, height;
52         vector bW, bH;
53         //pic = draw_UseSkinFor(pic);
54         width = eX * theSize.x;
55         height = eY * theSize.y;
56         if(theSize.x <= theBorderSize.x * 2)
57         {
58                 // not wide enough... draw just left and right then
59                 bW = eX * (0.25 * theSize.x / (theBorderSize.x * 2));
60                 if(theSize.y <= theBorderSize.y * 2)
61                 {
62                         // not high enough... draw just corners
63                         bH = eY * (0.25 * theSize.y / (theBorderSize.y * 2));
64                         drawsubpic(theOrigin,                 width * 0.5 + height * 0.5, pic, '0 0 0',           bW + bH, theColor, theAlpha, 0);
65                         drawsubpic(theOrigin + width   * 0.5, width * 0.5 + height * 0.5, pic, eX - bW,           bW + bH, theColor, theAlpha, 0);
66                         drawsubpic(theOrigin + height  * 0.5, width * 0.5 + height * 0.5, pic, eY - bH,           bW + bH, theColor, theAlpha, 0);
67                         drawsubpic(theOrigin + theSize * 0.5, width * 0.5 + height * 0.5, pic, eX + eY - bW - bH, bW + bH, theColor, theAlpha, 0);
68                 }
69                 else
70                 {
71                         dY = theBorderSize.x * eY;
72                         drawsubpic(theOrigin,                             width * 0.5          +     dY, pic, '0 0    0',           '0 0.25 0' + bW, theColor, theAlpha, 0);
73                         drawsubpic(theOrigin + width * 0.5,               width * 0.5          +     dY, pic, '0 0    0' + eX - bW, '0 0.25 0' + bW, theColor, theAlpha, 0);
74                         drawsubpic(theOrigin                        + dY, width * 0.5 + height - 2 * dY, pic, '0 0.25 0',           '0 0.5  0' + bW, theColor, theAlpha, 0);
75                         drawsubpic(theOrigin + width * 0.5          + dY, width * 0.5 + height - 2 * dY, pic, '0 0.25 0' + eX - bW, '0 0.5  0' + bW, theColor, theAlpha, 0);
76                         drawsubpic(theOrigin               + height - dY, width * 0.5          +     dY, pic, '0 0.75 0',           '0 0.25 0' + bW, theColor, theAlpha, 0);
77                         drawsubpic(theOrigin + width * 0.5 + height - dY, width * 0.5          +     dY, pic, '0 0.75 0' + eX - bW, '0 0.25 0' + bW, theColor, theAlpha, 0);
78                 }
79         }
80         else
81         {
82                 if(theSize.y <= theBorderSize.y * 2)
83                 {
84                         // not high enough... draw just top and bottom then
85                         bH = eY * (0.25 * theSize.y / (theBorderSize.y * 2));
86                         dX = theBorderSize.x * eX;
87                         drawsubpic(theOrigin,                                         dX + height * 0.5, pic, '0    0 0',           '0.25 0 0' + bH, theColor, theAlpha, 0);
88                         drawsubpic(theOrigin + dX,                        width - 2 * dX + height * 0.5, pic, '0.25 0 0',           '0.5  0 0' + bH, theColor, theAlpha, 0);
89                         drawsubpic(theOrigin + width - dX,                            dX + height * 0.5, pic, '0.75 0 0',           '0.25 0 0' + bH, theColor, theAlpha, 0);
90                         drawsubpic(theOrigin              + height * 0.5,             dX + height * 0.5, pic, '0    0 0' + eY - bH, '0.25 0 0' + bH, theColor, theAlpha, 0);
91                         drawsubpic(theOrigin + dX         + height * 0.5, width - 2 * dX + height * 0.5, pic, '0.25 0 0' + eY - bH, '0.5  0 0' + bH, theColor, theAlpha, 0);
92                         drawsubpic(theOrigin + width - dX + height * 0.5,             dX + height * 0.5, pic, '0.75 0 0' + eY - bH, '0.25 0 0' + bH, theColor, theAlpha, 0);
93                 }
94                 else
95                 {
96                         dX = theBorderSize.x * eX;
97                         dY = theBorderSize.x * eY;
98                         drawsubpic(theOrigin,                                        dX          +     dY, pic, '0    0    0', '0.25 0.25 0', theColor, theAlpha, 0);
99                         drawsubpic(theOrigin                  + dX,      width - 2 * dX          +     dY, pic, '0.25 0    0', '0.5  0.25 0', theColor, theAlpha, 0);
100                         drawsubpic(theOrigin          + width - dX,                  dX          +     dY, pic, '0.75 0    0', '0.25 0.25 0', theColor, theAlpha, 0);
101                         drawsubpic(theOrigin          + dY,                          dX + height - 2 * dY, pic, '0    0.25 0', '0.25 0.5  0', theColor, theAlpha, 0);
102                         drawsubpic(theOrigin          + dY         + dX, width - 2 * dX + height - 2 * dY, pic, '0.25 0.25 0', '0.5  0.5  0', theColor, theAlpha, 0);
103                         drawsubpic(theOrigin          + dY + width - dX,             dX + height - 2 * dY, pic, '0.75 0.25 0', '0.25 0.5  0', theColor, theAlpha, 0);
104                         drawsubpic(theOrigin + height - dY,                          dX          +     dY, pic, '0    0.75 0', '0.25 0.25 0', theColor, theAlpha, 0);
105                         drawsubpic(theOrigin + height - dY         + dX, width - 2 * dX          +     dY, pic, '0.25 0.75 0', '0.5  0.25 0', theColor, theAlpha, 0);
106                         drawsubpic(theOrigin + height - dY + width - dX,             dX          +     dY, pic, '0.75 0.75 0', '0.25 0.25 0', theColor, theAlpha, 0);
107                 }
108         }
109 }
110
111 vector HUD_Get_Num_Color (float x, float maxvalue)
112 {
113         float blinkingamt;
114         vector color;
115         if(x >= maxvalue) {
116                 color.x = sin(2*M_PI*time);
117                 color.y = 1;
118                 color.z = sin(2*M_PI*time);
119         }
120         else if(x > maxvalue * 0.75) {
121                 color.x = 0.4 - (x-150)*0.02 * 0.4; //red value between 0.4 -> 0
122                 color.y = 0.9 + (x-150)*0.02 * 0.1; // green value between 0.9 -> 1
123                 color.z = 0;
124         }
125         else if(x > maxvalue * 0.5) {
126                 color.x = 1 - (x-100)*0.02 * 0.6; //red value between 1 -> 0.4
127                 color.y = 1 - (x-100)*0.02 * 0.1; // green value between 1 -> 0.9
128                 color.z = 1 - (x-100)*0.02; // blue value between 1 -> 0
129         }
130         else if(x > maxvalue * 0.25) {
131                 color.x = 1;
132                 color.y = 1;
133                 color.z = 0.2 + (x-50)*0.02 * 0.8; // blue value between 0.2 -> 1
134         }
135         else if(x > maxvalue * 0.1) {
136                 color.x = 1;
137                 color.y = (x-20)*90/27/100; // green value between 0 -> 1
138                 color.z = (x-20)*90/27/100 * 0.2; // blue value between 0 -> 0.2
139         }
140         else {
141                 color.x = 1;
142                 color.y = 0;
143                 color.z = 0;
144         }
145
146         blinkingamt = (1 - x/maxvalue/0.25);
147         if(blinkingamt > 0)
148         {
149                 color.x = color.x - color.x * blinkingamt * sin(2*M_PI*time);
150                 color.y = color.y - color.y * blinkingamt * sin(2*M_PI*time);
151                 color.z = color.z - color.z * blinkingamt * sin(2*M_PI*time);
152         }
153         return color;
154 }
155
156 float HUD_GetRowCount(int item_count, vector size, float item_aspect)
157 {
158         float aspect = size_y / size_x;
159         return bound(1, floor((sqrt(4 * item_aspect * aspect * item_count + aspect * aspect) + aspect + 0.5) / 2), item_count);
160 }
161
162 vector HUD_GetTableSize(int item_count, vector psize, float item_aspect)
163 {
164         float columns, rows;
165         float ratio, best_ratio = 0;
166         float best_columns = 1, best_rows = 1;
167         bool vertical = (psize.x / psize.y >= item_aspect);
168         if(vertical)
169         {
170                 psize = eX * psize.y + eY * psize.x;
171                 item_aspect = 1 / item_aspect;
172         }
173
174         rows = ceil(sqrt(item_count));
175         columns = ceil(item_count/rows);
176         while(columns >= 1)
177         {
178                 ratio = (psize.x/columns) / (psize.y/rows);
179                 if(ratio > item_aspect)
180                         ratio = item_aspect * item_aspect / ratio;
181
182                 if(ratio <= best_ratio)
183                         break; // ratio starts decreasing by now, skip next configurations
184
185                 best_columns = columns;
186                 best_rows = rows;
187                 best_ratio = ratio;
188
189                 if(columns == 1)
190                         break;
191
192                 --columns;
193                 rows = ceil(item_count/columns);
194         }
195
196         if(vertical)
197                 return eX * best_rows + eY * best_columns;
198         else
199                 return eX * best_columns + eY * best_rows;
200 }
201
202 float stringwidth_colors(string s, vector theSize)
203 {
204         return stringwidth(s, true, theSize);
205 }
206
207 float stringwidth_nocolors(string s, vector theSize)
208 {
209         return stringwidth(s, false, theSize);
210 }
211
212 void drawstringright(vector position, string text, vector theScale, vector rgb, float theAlpha, int flag)
213 {
214         position.x -= 2 / 3 * strlen(text) * theScale.x;
215         drawstring(position, text, theScale, rgb, theAlpha, flag);
216 }
217
218 void drawstringcenter(vector position, string text, vector theScale, vector rgb, float theAlpha, int flag)
219 {
220         position.x = 0.5 * (vid_conwidth - 0.6025 * strlen(text) * theScale.x);
221         drawstring(position, text, theScale, rgb, theAlpha, flag);
222 }
223
224 // return the string of the onscreen race timer
225 string MakeRaceString(int cp, float mytime, float theirtime, float lapdelta, string theirname)
226 {
227         string col;
228         string timestr;
229         string cpname;
230         string lapstr;
231         lapstr = "";
232
233         if(theirtime == 0) // goal hit
234         {
235                 if(mytime > 0)
236                 {
237                         timestr = strcat("+", ftos_decimals(+mytime, TIME_DECIMALS));
238                         col = "^1";
239                 }
240                 else if(mytime == 0)
241                 {
242                         timestr = "+0.0";
243                         col = "^3";
244                 }
245                 else
246                 {
247                         timestr = strcat("-", ftos_decimals(-mytime, TIME_DECIMALS));
248                         col = "^2";
249                 }
250
251                 if(lapdelta > 0)
252                 {
253                         lapstr = sprintf(_(" (-%dL)"), lapdelta);
254                         col = "^2";
255                 }
256                 else if(lapdelta < 0)
257                 {
258                         lapstr = sprintf(_(" (+%dL)"), -lapdelta);
259                         col = "^1";
260                 }
261         }
262         else if(theirtime > 0) // anticipation
263         {
264                 if(mytime >= theirtime)
265                         timestr = strcat("+", ftos_decimals(mytime - theirtime, TIME_DECIMALS));
266                 else
267                         timestr = TIME_ENCODED_TOSTRING(TIME_ENCODE(theirtime));
268                 col = "^3";
269         }
270         else
271         {
272                 col = "^7";
273                 timestr = "";
274         }
275
276         if(cp == 254)
277                 cpname = _("Start line");
278         else if(cp == 255)
279                 cpname = _("Finish line");
280         else if(cp)
281                 cpname = sprintf(_("Intermediate %d"), cp);
282         else
283                 cpname = _("Finish line");
284
285         if(theirtime < 0)
286                 return strcat(col, cpname);
287         else if(theirname == "")
288                 return strcat(col, sprintf("%s (%s)", cpname, timestr));
289         else
290                 return strcat(col, sprintf("%s (%s %s)", cpname, timestr, strcat(theirname, col, lapstr)));
291 }
292
293 // Check if the given name already exist in race rankings? In that case, where? (otherwise return 0)
294 int race_CheckName(string net_name)
295 {
296         int i;
297         for (i=RANKINGS_CNT-1;i>=0;--i)
298                 if(grecordholder[i] == net_name)
299                         return i+1;
300         return 0;
301 }
302
303 int GetPlayerColorForce(int i)
304 {
305         if(!teamplay)
306                 return 0;
307         else
308                 return stof(getplayerkeyvalue(i, "colors")) & 15;
309 }
310
311 int GetPlayerColor(int i)
312 {
313         if(!playerslots[i].gotscores) // unconnected
314                 return NUM_SPECTATOR;
315         else if(stof(getplayerkeyvalue(i, "frags")) == FRAGS_SPECTATOR)
316                 return NUM_SPECTATOR;
317         else
318                 return GetPlayerColorForce(i);
319 }
320
321 string GetPlayerName(int i)
322 {
323         return ColorTranslateRGB(getplayerkeyvalue(i, "name"));
324 }
325
326
327 /*
328 ==================
329 HUD panels
330 ==================
331 */
332
333 // draw the background/borders
334 #define HUD_Panel_DrawBg(theAlpha) do {                                                                                                                                                         \
335         if(panel.current_panel_bg != "0" && panel.current_panel_bg != "")                                                                                               \
336                 draw_BorderPicture(panel_pos - '1 1 0' * panel_bg_border, panel.current_panel_bg, panel_size + '1 1 0' * 2 * panel_bg_border, panel_bg_color, panel_bg_alpha * theAlpha, '1 1 0' * (panel_bg_border/BORDER_MULTIPLIER));\
337 } while(0)
338
339 //basically the same code of draw_ButtonPicture and draw_VertButtonPicture for the menu
340 void HUD_Panel_DrawProgressBar(vector theOrigin, vector theSize, string pic, float length_ratio, bool vertical, float baralign, vector theColor, float theAlpha, int drawflag)
341 {
342         if(!length_ratio || !theAlpha)
343                 return;
344         if(length_ratio > 1)
345                 length_ratio = 1;
346         if (baralign == 3)
347         {
348                 if(length_ratio < -1)
349                         length_ratio = -1;
350         }
351         else if(length_ratio < 0)
352                 return;
353
354         vector square;
355         vector width, height;
356         if(vertical) {
357                 pic = strcat(hud_skin_path, "/", pic, "_vertical");
358                 if(precache_pic(pic) == "") {
359                         pic = "gfx/hud/default/progressbar_vertical";
360                 }
361
362         if (baralign == 1) // bottom align
363                         theOrigin.y += (1 - length_ratio) * theSize.y;
364         else if (baralign == 2) // center align
365             theOrigin.y += 0.5 * (1 - length_ratio) * theSize.y;
366         else if (baralign == 3) // center align, positive values down, negative up
367                 {
368                         theSize.y *= 0.5;
369                         if (length_ratio > 0)
370                                 theOrigin.y += theSize.y;
371                         else
372                         {
373                                 theOrigin.y += (1 + length_ratio) * theSize.y;
374                                 length_ratio = -length_ratio;
375                         }
376                 }
377                 theSize.y *= length_ratio;
378
379                 vector bH;
380                 width = eX * theSize.x;
381                 height = eY * theSize.y;
382                 if(theSize.y <= theSize.x * 2)
383                 {
384                         // button not high enough
385                         // draw just upper and lower part then
386                         square = eY * theSize.y * 0.5;
387                         bH = eY * (0.25 * theSize.y / (theSize.x * 2));
388                         drawsubpic(theOrigin,          square + width, pic, '0 0 0', eX + bH, theColor, theAlpha, drawflag);
389                         drawsubpic(theOrigin + square, square + width, pic, eY - bH, eX + bH, theColor, theAlpha, drawflag);
390                 }
391                 else
392                 {
393                         square = eY * theSize.x;
394                         drawsubpic(theOrigin,                   width   +     square, pic, '0 0    0', '1 0.25 0', theColor, theAlpha, drawflag);
395                         drawsubpic(theOrigin +          square, theSize - 2 * square, pic, '0 0.25 0', '1 0.5  0', theColor, theAlpha, drawflag);
396                         drawsubpic(theOrigin + height - square, width   +     square, pic, '0 0.75 0', '1 0.25 0', theColor, theAlpha, drawflag);
397                 }
398         } else {
399                 pic = strcat(hud_skin_path, "/", pic);
400                 if(precache_pic(pic) == "") {
401                         pic = "gfx/hud/default/progressbar";
402                 }
403
404                 if (baralign == 1) // right align
405                         theOrigin.x += (1 - length_ratio) * theSize.x;
406         else if (baralign == 2) // center align
407             theOrigin.x += 0.5 * (1 - length_ratio) * theSize.x;
408         else if (baralign == 3) // center align, positive values on the right, negative on the left
409                 {
410                         theSize.x *= 0.5;
411                         if (length_ratio > 0)
412                                 theOrigin.x += theSize.x;
413                         else
414                         {
415                                 theOrigin.x += (1 + length_ratio) * theSize.x;
416                                 length_ratio = -length_ratio;
417                         }
418                 }
419                 theSize.x *= length_ratio;
420
421                 vector bW;
422                 width = eX * theSize.x;
423                 height = eY * theSize.y;
424                 if(theSize.x <= theSize.y * 2)
425                 {
426                         // button not wide enough
427                         // draw just left and right part then
428                         square = eX * theSize.x * 0.5;
429                         bW = eX * (0.25 * theSize.x / (theSize.y * 2));
430                         drawsubpic(theOrigin,          square + height, pic, '0 0 0', eY + bW, theColor, theAlpha, drawflag);
431                         drawsubpic(theOrigin + square, square + height, pic, eX - bW, eY + bW, theColor, theAlpha, drawflag);
432                 }
433                 else
434                 {
435                         square = eX * theSize.y;
436                         drawsubpic(theOrigin,                  height  +     square, pic, '0    0 0', '0.25 1 0', theColor, theAlpha, drawflag);
437                         drawsubpic(theOrigin +         square, theSize - 2 * square, pic, '0.25 0 0', '0.5  1 0', theColor, theAlpha, drawflag);
438                         drawsubpic(theOrigin + width - square, height  +     square, pic, '0.75 0 0', '0.25 1 0', theColor, theAlpha, drawflag);
439                 }
440         }
441 }
442
443 void HUD_Panel_DrawHighlight(vector pos, vector mySize, vector color, float theAlpha, int drawflag)
444 {
445         if(!theAlpha)
446                 return;
447
448         string pic;
449         pic = strcat(hud_skin_path, "/num_leading");
450         if(precache_pic(pic) == "") {
451                 pic = "gfx/hud/default/num_leading";
452         }
453
454         drawsubpic(pos, eX * min(mySize.x * 0.5, mySize.y) + eY * mySize.y, pic, '0 0 0', '0.25 1 0', color, theAlpha, drawflag);
455         if(mySize.x/mySize.y > 2)
456                 drawsubpic(pos + eX * mySize.y, eX * (mySize.x - 2 * mySize.y) + eY * mySize.y, pic, '0.25 0 0', '0.5 1 0', color, theAlpha, drawflag);
457         drawsubpic(pos + eX * mySize.x - eX * min(mySize.x * 0.5, mySize.y), eX * min(mySize.x * 0.5, mySize.y) + eY * mySize.y, pic, '0.75 0 0', '0.25 1 0', color, theAlpha, drawflag);
458 }
459
460 // Weapon icons (#0)
461 //
462 entity weaponorder[WEP_MAXCOUNT];
463 void weaponorder_swap(int i, int j, entity pass)
464 {
465         entity h = weaponorder[i];
466         weaponorder[i] = weaponorder[j];
467         weaponorder[j] = h;
468 }
469
470 string weaponorder_cmp_str;
471 int weaponorder_cmp(int i, int j, entity pass)
472 {
473         int ai, aj;
474         ai = strstrofs(weaponorder_cmp_str, sprintf(" %d ", weaponorder[i].weapon), 0);
475         aj = strstrofs(weaponorder_cmp_str, sprintf(" %d ", weaponorder[j].weapon), 0);
476         return aj - ai; // the string is in REVERSE order (higher prio at the right is what we want, but higher prio first is the string)
477 }
478
479 void HUD_Weapons(void)
480 {
481         // declarations
482         WepSet weapons_stat = WepSet_GetFromStat();
483         int i;
484         float f, a;
485         float screen_ar;
486         vector center = '0 0 0';
487         int weapon_count, weapon_id;
488         int row, column, rows = 0, columns = 0;
489         bool vertical_order = true;
490         float aspect = autocvar_hud_panel_weapons_aspect;
491
492         float timeout = autocvar_hud_panel_weapons_timeout;
493         float timein_effect_length = autocvar_hud_panel_weapons_timeout_speed_in; //? 0.375 : 0);
494         float timeout_effect_length = autocvar_hud_panel_weapons_timeout_speed_out; //? 0.75 : 0);
495
496         vector barsize = '0 0 0', baroffset = '0 0 0';
497         vector ammo_color = '1 0 1';
498         float ammo_alpha = 1;
499
500         float when = max(1, autocvar_hud_panel_weapons_complainbubble_time);
501         float fadetime = max(0, autocvar_hud_panel_weapons_complainbubble_fadetime);
502
503         vector weapon_pos, weapon_size = '0 0 0';
504         vector color;
505
506         // check to see if we want to continue
507         if(hud != HUD_NORMAL) { return; }
508
509         if(!autocvar__hud_configure)
510         {
511                 if((!autocvar_hud_panel_weapons) || (spectatee_status == -1))
512                         return;
513                 if(timeout && time >= weapontime + timeout + timeout_effect_length)
514                 if(autocvar_hud_panel_weapons_timeout_effect == 3 || (autocvar_hud_panel_weapons_timeout_effect == 1 && !(autocvar_hud_panel_weapons_timeout_fadebgmin + autocvar_hud_panel_weapons_timeout_fadefgmin)))
515                 {
516                         weaponprevtime = time;
517                         return;
518                 }
519         }
520
521         // update generic hud functions
522         HUD_Panel_UpdateCvars();
523
524         // figure out weapon order (how the weapons are sorted) // TODO make this configurable
525         if(weaponorder_bypriority != autocvar_cl_weaponpriority || !weaponorder[0])
526         {
527                 int weapon_cnt;
528                 if(weaponorder_bypriority)
529                         strunzone(weaponorder_bypriority);
530                 if(weaponorder_byimpulse)
531                         strunzone(weaponorder_byimpulse);
532
533                 weaponorder_bypriority = strzone(autocvar_cl_weaponpriority);
534                 weaponorder_byimpulse = strzone(W_FixWeaponOrder_BuildImpulseList(W_FixWeaponOrder_ForceComplete(W_NumberWeaponOrder(weaponorder_bypriority))));
535                 weaponorder_cmp_str = strcat(" ", weaponorder_byimpulse, " ");
536
537                 weapon_cnt = 0;
538                 for(i = WEP_FIRST; i <= WEP_LAST; ++i)
539                 {
540                         self = get_weaponinfo(i);
541                         if(self.impulse >= 0)
542                         {
543                                 weaponorder[weapon_cnt] = self;
544                                 ++weapon_cnt;
545                         }
546                 }
547                 for(i = weapon_cnt; i < WEP_MAXCOUNT; ++i)
548                         weaponorder[i] = world;
549                 heapsort(weapon_cnt, weaponorder_swap, weaponorder_cmp, world);
550
551                 weaponorder_cmp_str = string_null;
552         }
553
554         if(!autocvar_hud_panel_weapons_complainbubble || autocvar__hud_configure || time - complain_weapon_time >= when + fadetime)
555                 complain_weapon = 0;
556
557         if(autocvar__hud_configure)
558         {
559                 if(!weapons_stat)
560                         for(i = WEP_FIRST; i <= WEP_LAST; i += floor((WEP_LAST-WEP_FIRST)/5))
561                                 weapons_stat |= WepSet_FromWeapon(i);
562
563                 #if 0
564                 /// debug code
565                 if(cvar("wep_add"))
566                 {
567                         weapons_stat = '0 0 0';
568                         float countw = 1 + floor((floor(time * cvar("wep_add"))) % WEP_COUNT);
569                         for(i = WEP_FIRST; i <= countw; ++i)
570                                 weapons_stat |= WepSet_FromWeapon(i);
571                 }
572                 #endif
573         }
574
575         // determine which weapons are going to be shown
576         if (autocvar_hud_panel_weapons_onlyowned)
577         {
578                 if(autocvar__hud_configure)
579                 {
580                         if(menu_enabled != 2)
581                                 HUD_Panel_DrawBg(1); // also draw the bg of the entire panel
582                 }
583
584                 // do we own this weapon?
585                 weapon_count = 0;
586                 for(i = 0; i <= WEP_LAST-WEP_FIRST; ++i)
587                         if((weapons_stat & WepSet_FromWeapon(weaponorder[i].weapon)) || (weaponorder[i].weapon == complain_weapon))
588                                 ++weapon_count;
589
590
591                 // might as well commit suicide now, no reason to live ;)
592                 if (weapon_count == 0)
593                         return;
594
595                 vector old_panel_size = panel_size;
596                 vector padded_panel_size = panel_size - '2 2 0' * panel_bg_padding;
597
598                 // get the all-weapons layout
599                 vector table_size = HUD_GetTableSize(WEP_COUNT, padded_panel_size, aspect);
600                 columns = table_size.x;
601                 rows = table_size.y;
602                 weapon_size.x = padded_panel_size.x / columns;
603                 weapon_size.y = padded_panel_size.y / rows;
604
605                 // NOTE: although weapons should aways look the same even if onlyowned is enabled,
606                 // we enlarge them a bit when possible to better match the desired aspect ratio
607                 if(padded_panel_size.x / padded_panel_size.y < aspect)
608                 {
609                         // maximum number of rows that allows to display items with the desired aspect ratio
610                         int max_rows = floor(padded_panel_size.y / (weapon_size.x / aspect));
611                         columns = min(columns, ceil(weapon_count / max_rows));
612                         rows = ceil(weapon_count / columns);
613                         weapon_size.y = min(padded_panel_size.y / rows, weapon_size.x / aspect);
614                         weapon_size.x = min(padded_panel_size.x / columns, aspect * weapon_size.y);
615                         vertical_order = false;
616                 }
617                 else
618                 {
619                         int max_columns = floor(padded_panel_size.x / (weapon_size.y * aspect));
620                         rows = min(rows, ceil(weapon_count / max_columns));
621                         columns = ceil(weapon_count / rows);
622                         weapon_size.x = min(padded_panel_size.x / columns, aspect * weapon_size.y);
623                         weapon_size.y = min(padded_panel_size.y / rows, weapon_size.x / aspect);
624                         vertical_order = true;
625                 }
626
627                 // reduce size of the panel
628                 panel_size.x = columns * weapon_size.x;
629                 panel_size.y = rows * weapon_size.y;
630                 panel_size += '2 2 0' * panel_bg_padding;
631
632                 // center the resized panel, or snap it to the screen edge when close enough
633                 if(panel_pos.x > vid_conwidth * 0.001)
634                 {
635                         if(panel_pos.x + old_panel_size.x > vid_conwidth * 0.999)
636                                 panel_pos.x += old_panel_size.x - panel_size.x;
637                         else
638                                 panel_pos.x += (old_panel_size.x - panel_size.x) / 2;
639                 }
640                 else if(old_panel_size.x > vid_conwidth * 0.999)
641                         panel_pos.x += (old_panel_size.x - panel_size.x) / 2;
642
643                 if(panel_pos.y > vid_conheight * 0.001)
644                 {
645                         if(panel_pos.y + old_panel_size.y > vid_conheight * 0.999)
646                                 panel_pos.y += old_panel_size.y - panel_size.y;
647                         else
648                                 panel_pos.y += (old_panel_size.y - panel_size.y) / 2;
649                 }
650                 else if(old_panel_size.y > vid_conheight * 0.999)
651                         panel_pos.y += (old_panel_size.y - panel_size.y) / 2;
652         }
653         else
654                 weapon_count = WEP_COUNT;
655
656         // animation for fading in/out the panel respectively when not in use
657         if(!autocvar__hud_configure)
658         {
659                 if (timeout && time >= weapontime + timeout) // apply timeout effect if needed
660                 {
661                         f = bound(0, (time - (weapontime + timeout)) / timeout_effect_length, 1);
662
663                         // fade the panel alpha
664                         if(autocvar_hud_panel_weapons_timeout_effect == 1)
665                         {
666                                 panel_bg_alpha *= (autocvar_hud_panel_weapons_timeout_fadebgmin * f + (1 - f));
667                                 panel_fg_alpha *= (autocvar_hud_panel_weapons_timeout_fadefgmin * f + (1 - f));
668                         }
669                         else if(autocvar_hud_panel_weapons_timeout_effect == 3)
670                         {
671                                 panel_bg_alpha *= (1 - f);
672                                 panel_fg_alpha *= (1 - f);
673                         }
674
675                         // move the panel off the screen
676                         if (autocvar_hud_panel_weapons_timeout_effect == 2 || autocvar_hud_panel_weapons_timeout_effect == 3)
677                         {
678                                 f *= f; // for a cooler movement
679                                 center.x = panel_pos.x + panel_size.x/2;
680                                 center.y = panel_pos.y + panel_size.y/2;
681                                 screen_ar = vid_conwidth/vid_conheight;
682                                 if (center.x/center.y < screen_ar) //bottom left
683                                 {
684                                         if ((vid_conwidth - center.x)/center.y < screen_ar) //bottom
685                                                 panel_pos.y += f * (vid_conheight - panel_pos.y);
686                                         else //left
687                                                 panel_pos.x -= f * (panel_pos.x + panel_size.x);
688                                 }
689                                 else //top right
690                                 {
691                                         if ((vid_conwidth - center.x)/center.y < screen_ar) //right
692                                                 panel_pos.x += f * (vid_conwidth - panel_pos.x);
693                                         else //top
694                                                 panel_pos.y -= f * (panel_pos.y + panel_size.y);
695                                 }
696                                 if(f == 1)
697                                         center.x = -1; // mark the panel as off screen
698                         }
699                         weaponprevtime = time - (1 - f) * timein_effect_length;
700                 }
701                 else if (timeout && time < weaponprevtime + timein_effect_length) // apply timein effect if needed
702                 {
703                         f = bound(0, (time - weaponprevtime) / timein_effect_length, 1);
704
705                         // fade the panel alpha
706                         if(autocvar_hud_panel_weapons_timeout_effect == 1)
707                         {
708                                 panel_bg_alpha *= (autocvar_hud_panel_weapons_timeout_fadebgmin * (1 - f) + f);
709                                 panel_fg_alpha *= (autocvar_hud_panel_weapons_timeout_fadefgmin * (1 - f) + f);
710                         }
711                         else if(autocvar_hud_panel_weapons_timeout_effect == 3)
712                         {
713                                 panel_bg_alpha *= (f);
714                                 panel_fg_alpha *= (f);
715                         }
716
717                         // move the panel back on screen
718                         if (autocvar_hud_panel_weapons_timeout_effect == 2 || autocvar_hud_panel_weapons_timeout_effect == 3)
719                         {
720                                 f *= f; // for a cooler movement
721                                 f = 1 - f;
722                                 center.x = panel_pos.x + panel_size.x/2;
723                                 center.y = panel_pos.y + panel_size.y/2;
724                                 screen_ar = vid_conwidth/vid_conheight;
725                                 if (center.x/center.y < screen_ar) //bottom left
726                                 {
727                                         if ((vid_conwidth - center.x)/center.y < screen_ar) //bottom
728                                                 panel_pos.y += f * (vid_conheight - panel_pos.y);
729                                         else //left
730                                                 panel_pos.x -= f * (panel_pos.x + panel_size.x);
731                                 }
732                                 else //top right
733                                 {
734                                         if ((vid_conwidth - center.x)/center.y < screen_ar) //right
735                                                 panel_pos.x += f * (vid_conwidth - panel_pos.x);
736                                         else //top
737                                                 panel_pos.y -= f * (panel_pos.y + panel_size.y);
738                                 }
739                         }
740                 }
741         }
742
743         // draw the background, then change the virtual size of it to better fit other items inside
744         HUD_Panel_DrawBg(1);
745
746         if(center.x == -1)
747                 return;
748
749         if(panel_bg_padding)
750         {
751                 panel_pos += '1 1 0' * panel_bg_padding;
752                 panel_size -= '2 2 0' * panel_bg_padding;
753         }
754
755         // after the sizing and animations are done, update the other values
756
757         if(!rows) // if rows is > 0 onlyowned code has already updated these vars
758         {
759                 vector table_size = HUD_GetTableSize(WEP_COUNT, panel_size, aspect);
760                 columns = table_size.x;
761                 rows = table_size.y;
762                 weapon_size.x = panel_size.x / columns;
763                 weapon_size.y = panel_size.y / rows;
764                 vertical_order = (panel_size.x / panel_size.y >= aspect);
765         }
766
767         // calculate position/size for visual bar displaying ammount of ammo status
768         if (autocvar_hud_panel_weapons_ammo)
769         {
770                 ammo_color = stov(autocvar_hud_panel_weapons_ammo_color);
771                 ammo_alpha = panel_fg_alpha * autocvar_hud_panel_weapons_ammo_alpha;
772
773                 if(weapon_size.x/weapon_size.y > aspect)
774                 {
775                         barsize.x = aspect * weapon_size.y;
776                         barsize.y = weapon_size.y;
777                         baroffset.x = (weapon_size.x - barsize.x) / 2;
778                 }
779                 else
780                 {
781                         barsize.y = 1/aspect * weapon_size.x;
782                         barsize.x = weapon_size.x;
783                         baroffset.y = (weapon_size.y - barsize.y) / 2;
784                 }
785         }
786         if(autocvar_hud_panel_weapons_accuracy)
787                 Accuracy_LoadColors();
788
789         // draw items
790         row = column = 0;
791         vector label_size = '1 1 0' * min(weapon_size.x, weapon_size.y) * bound(0, autocvar_hud_panel_weapons_label_scale, 1);
792         vector noncurrent_pos = '0 0 0';
793         vector noncurrent_size = weapon_size * bound(0, autocvar_hud_panel_weapons_noncurrent_scale, 1);
794         float noncurrent_alpha = panel_fg_alpha * bound(0, autocvar_hud_panel_weapons_noncurrent_alpha, 1);
795         bool isCurrent;
796
797         for(i = 0; i <= WEP_LAST-WEP_FIRST; ++i)
798         {
799                 // retrieve information about the current weapon to be drawn
800                 self = weaponorder[i];
801                 weapon_id = self.impulse;
802                 isCurrent = (self.weapon == switchweapon);
803
804                 // skip if this weapon doesn't exist
805                 if(!self || weapon_id < 0) { continue; }
806
807                 // skip this weapon if we don't own it (and onlyowned is enabled)-- or if weapons_complainbubble is showing for this weapon
808                 if(autocvar_hud_panel_weapons_onlyowned)
809                 if (!((weapons_stat & WepSet_FromWeapon(self.weapon)) || (self.weapon == complain_weapon)))
810                         continue;
811
812                 // figure out the drawing position of weapon
813                 weapon_pos = (panel_pos + eX * column * weapon_size.x + eY * row * weapon_size.y);
814                 noncurrent_pos.x = weapon_pos.x + (weapon_size.x - noncurrent_size.x) / 2;
815                 noncurrent_pos.y = weapon_pos.y + (weapon_size.y - noncurrent_size.y) / 2;
816
817                 // draw background behind currently selected weapon
818                 if(isCurrent)
819                         drawpic_aspect_skin(weapon_pos, "weapon_current_bg", weapon_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
820
821                 // draw the weapon accuracy
822                 if(autocvar_hud_panel_weapons_accuracy)
823                 {
824                         float panel_weapon_accuracy = weapon_accuracy[self.weapon-WEP_FIRST];
825                         if(panel_weapon_accuracy >= 0)
826                         {
827                                 color = Accuracy_GetColor(panel_weapon_accuracy);
828                                 drawpic_aspect_skin(weapon_pos, "weapon_accuracy", weapon_size, color, panel_fg_alpha, DRAWFLAG_NORMAL);
829                         }
830                 }
831
832                 // drawing all the weapon items
833                 if(weapons_stat & WepSet_FromWeapon(self.weapon))
834                 {
835                         // draw the weapon image
836                         if(isCurrent)
837                                 drawpic_aspect_skin(weapon_pos, self.model2, weapon_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
838                         else
839                                 drawpic_aspect_skin(noncurrent_pos, self.model2, noncurrent_size, '1 1 1', noncurrent_alpha, DRAWFLAG_NORMAL);
840
841                         // draw weapon label string
842                         switch(autocvar_hud_panel_weapons_label)
843                         {
844                                 case 1: // weapon number
845                                         drawstring(weapon_pos, ftos(weapon_id), label_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
846                                         break;
847
848                                 case 2: // bind
849                                         drawstring(weapon_pos, getcommandkey(ftos(weapon_id), strcat("weapon_group_", ftos(weapon_id))), label_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
850                                         break;
851
852                                 case 3: // weapon name
853                                         drawstring(weapon_pos, strtolower(self.message), label_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
854                                         break;
855
856                                 default: // nothing
857                                         break;
858                         }
859
860                         // draw ammo status bar
861                         if(autocvar_hud_panel_weapons_ammo && (self.ammo_field != ammo_none))
862                         {
863                                 float ammo_full;
864                                 a = getstati(GetAmmoStat(self.ammo_field)); // how much ammo do we have?
865
866                                 if(a > 0)
867                                 {
868                                         switch(self.ammo_field)
869                                         {
870                                                 case ammo_shells:  ammo_full = autocvar_hud_panel_weapons_ammo_full_shells;  break;
871                                                 case ammo_nails:   ammo_full = autocvar_hud_panel_weapons_ammo_full_nails;   break;
872                                                 case ammo_rockets: ammo_full = autocvar_hud_panel_weapons_ammo_full_rockets; break;
873                                                 case ammo_cells:   ammo_full = autocvar_hud_panel_weapons_ammo_full_cells;   break;
874                                                 case ammo_plasma:  ammo_full = autocvar_hud_panel_weapons_ammo_full_plasma;  break;
875                                                 case ammo_fuel:    ammo_full = autocvar_hud_panel_weapons_ammo_full_fuel;    break;
876                                                 default: ammo_full = 60;
877                                         }
878
879                                         drawsetcliparea(
880                                                 weapon_pos.x + baroffset.x,
881                                                 weapon_pos.y + baroffset.y,
882                                                 barsize.x * bound(0, a/ammo_full, 1),
883                                                 barsize.y
884                                         );
885
886                                         drawpic_aspect_skin(
887                                                 weapon_pos,
888                                                 "weapon_ammo",
889                                                 weapon_size,
890                                                 ammo_color,
891                                                 ammo_alpha,
892                                                 DRAWFLAG_NORMAL
893                                         );
894
895                                         drawresetcliparea();
896                                 }
897                         }
898                 }
899                 else // draw a "ghost weapon icon" if you don't have the weapon
900                 {
901                         drawpic_aspect_skin(noncurrent_pos, self.model2, noncurrent_size, '0.2 0.2 0.2', panel_fg_alpha * 0.5, DRAWFLAG_NORMAL);
902                 }
903
904                 // draw the complain message
905                 if(self.weapon == complain_weapon)
906                 {
907                         if(fadetime)
908                                 a = ((complain_weapon_time + when > time) ? 1 : bound(0, (complain_weapon_time + when + fadetime - time) / fadetime, 1));
909                         else
910                                 a = ((complain_weapon_time + when > time) ? 1 : 0);
911
912                         string s;
913                         if(complain_weapon_type == 0) {
914                                 s = _("Out of ammo");
915                                 color = stov(autocvar_hud_panel_weapons_complainbubble_color_outofammo);
916                         }
917                         else if(complain_weapon_type == 1) {
918                                 s = _("Don't have");
919                                 color = stov(autocvar_hud_panel_weapons_complainbubble_color_donthave);
920                         }
921                         else {
922                                 s = _("Unavailable");
923                                 color = stov(autocvar_hud_panel_weapons_complainbubble_color_unavailable);
924                         }
925                         float padding = autocvar_hud_panel_weapons_complainbubble_padding;
926                         drawpic_aspect_skin(weapon_pos + '1 1 0' * padding, "weapon_complainbubble", weapon_size - '2 2 0' * padding, color, a * panel_fg_alpha, DRAWFLAG_NORMAL);
927                         drawstring_aspect(weapon_pos + '1 1 0' * padding, s, weapon_size - '2 2 0' * padding, '1 1 1', panel_fg_alpha * a, DRAWFLAG_NORMAL);
928                 }
929
930                 #if 0
931                 /// debug code
932                 if(!autocvar_hud_panel_weapons_onlyowned)
933                 {
934                         drawfill(weapon_pos + '1 1 0', weapon_size - '2 2 0', '1 1 1', panel_fg_alpha * 0.2, DRAWFLAG_NORMAL);
935                         drawstring(weapon_pos, ftos(i + 1), label_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
936                 }
937                 #endif
938
939                 // continue with new position for the next weapon
940                 if(vertical_order)
941                 {
942                         ++column;
943                         if(column >= columns)
944                         {
945                                 column = 0;
946                                 ++row;
947                         }
948                 }
949                 else
950                 {
951                         ++row;
952                         if(row >= rows)
953                         {
954                                 row = 0;
955                                 ++column;
956                         }
957                 }
958         }
959 }
960
961 // Ammo (#1)
962 void DrawNadeProgressBar(vector myPos, vector mySize, float progress, vector color)
963 {
964         HUD_Panel_DrawProgressBar(
965                 myPos + eX * autocvar_hud_panel_ammo_progressbar_xoffset * mySize.x,
966                 mySize - eX * autocvar_hud_panel_ammo_progressbar_xoffset * mySize.x,
967                 autocvar_hud_panel_ammo_progressbar_name,
968                 progress, 0, 0, color,
969                 autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
970 }
971
972 void DrawAmmoNades(vector myPos, vector mySize, bool draw_expanding, float expand_time)
973 {
974         float bonusNades    = getstatf(STAT_NADE_BONUS);
975         float bonusProgress = getstatf(STAT_NADE_BONUS_SCORE);
976         float bonusType     = getstati(STAT_NADE_BONUS_TYPE);
977         vector nadeColor    = Nade_Color(bonusType);
978         string nadeIcon     = Nade_Icon(bonusType);
979
980         vector iconPos, textPos;
981
982         if(autocvar_hud_panel_ammo_iconalign)
983         {
984                 iconPos = myPos + eX * 2 * mySize.y;
985                 textPos = myPos;
986         }
987         else
988         {
989                 iconPos = myPos;
990                 textPos = myPos + eX * mySize.y;
991         }
992
993         if(bonusNades > 0 || bonusProgress > 0)
994         {
995                 DrawNadeProgressBar(myPos, mySize, bonusProgress, nadeColor);
996
997                 if(autocvar_hud_panel_ammo_text)
998                         drawstring_aspect(textPos, ftos(bonusNades), eX * (2/3) * mySize.x + eY * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
999
1000                 if(draw_expanding)
1001                         drawpic_aspect_skin_expanding(iconPos, nadeIcon, '1 1 0' * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL, expand_time);
1002
1003                 drawpic_aspect_skin(iconPos, nadeIcon, '1 1 0' * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
1004         }
1005 }
1006
1007 void DrawAmmoItem(vector myPos, vector mySize, .int ammoType, bool isCurrent, bool isInfinite)
1008 {
1009         if(ammoType == ammo_none)
1010                 return;
1011
1012         // Initialize variables
1013
1014         int ammo;
1015         if(autocvar__hud_configure)
1016         {
1017                 isCurrent = (ammoType == ammo_rockets); // Rockets always current
1018                 ammo = 60;
1019         }
1020         else
1021                 ammo = getstati(GetAmmoStat(ammoType));
1022
1023         if(!isCurrent)
1024         {
1025                 float scale = bound(0, autocvar_hud_panel_ammo_noncurrent_scale, 1);
1026                 myPos = myPos + (mySize - mySize * scale) * 0.5;
1027                 mySize = mySize * scale;
1028         }
1029
1030         vector iconPos, textPos;
1031         if(autocvar_hud_panel_ammo_iconalign)
1032         {
1033                 iconPos = myPos + eX * 2 * mySize.y;
1034                 textPos = myPos;
1035         }
1036         else
1037         {
1038                 iconPos = myPos;
1039                 textPos = myPos + eX * mySize.y;
1040         }
1041
1042         bool isShadowed = (ammo <= 0 && !isCurrent && !isInfinite);
1043
1044         vector iconColor = isShadowed ? '0 0 0' : '1 1 1';
1045         vector textColor;
1046         if(isInfinite)
1047                 textColor = '0.2 0.95 0';
1048         else if(isShadowed)
1049                 textColor = '0 0 0';
1050         else if(ammo < 10)
1051                 textColor = '0.8 0.04 0';
1052         else
1053                 textColor = '1 1 1';
1054
1055         float alpha;
1056         if(isCurrent)
1057                 alpha = panel_fg_alpha;
1058         else if(isShadowed)
1059                 alpha = panel_fg_alpha * bound(0, autocvar_hud_panel_ammo_noncurrent_alpha, 1) * 0.5;
1060         else
1061                 alpha = panel_fg_alpha * bound(0, autocvar_hud_panel_ammo_noncurrent_alpha, 1);
1062
1063         string text = isInfinite ? "\xE2\x88\x9E" : ftos(ammo); // Use infinity symbol (U+221E)
1064
1065         // Draw item
1066
1067         if(isCurrent)
1068                 drawpic_aspect_skin(myPos, "ammo_current_bg", mySize, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
1069
1070         if(ammo > 0 && autocvar_hud_panel_ammo_progressbar)
1071                 HUD_Panel_DrawProgressBar(myPos + eX * autocvar_hud_panel_ammo_progressbar_xoffset * mySize.x, mySize - eX * autocvar_hud_panel_ammo_progressbar_xoffset * mySize.x, autocvar_hud_panel_ammo_progressbar_name, ammo/autocvar_hud_panel_ammo_maxammo, 0, 0, textColor, autocvar_hud_progressbar_alpha * alpha, DRAWFLAG_NORMAL);
1072
1073         if(autocvar_hud_panel_ammo_text)
1074                 drawstring_aspect(textPos, text, eX * (2/3) * mySize.x + eY * mySize.y, textColor, alpha, DRAWFLAG_NORMAL);
1075
1076         drawpic_aspect_skin(iconPos, GetAmmoPicture(ammoType), '1 1 0' * mySize.y, iconColor, alpha, DRAWFLAG_NORMAL);
1077 }
1078
1079 int nade_prevstatus;
1080 int nade_prevframe;
1081 float nade_statuschange_time;
1082 void HUD_Ammo(void)
1083 {
1084         if(hud != HUD_NORMAL) return;
1085         if(!autocvar__hud_configure)
1086         {
1087                 if(!autocvar_hud_panel_ammo) return;
1088                 if(spectatee_status == -1) return;
1089         }
1090
1091         HUD_Panel_UpdateCvars();
1092
1093         draw_beginBoldFont();
1094
1095         vector pos, mySize;
1096         pos = panel_pos;
1097         mySize = panel_size;
1098
1099         HUD_Panel_DrawBg(1);
1100         if(panel_bg_padding)
1101         {
1102                 pos += '1 1 0' * panel_bg_padding;
1103                 mySize -= '2 2 0' * panel_bg_padding;
1104         }
1105
1106         int rows = 0, columns, row, column;
1107         float nade_cnt = getstatf(STAT_NADE_BONUS), nade_score = getstatf(STAT_NADE_BONUS_SCORE);
1108         bool draw_nades = (nade_cnt > 0 || nade_score > 0);
1109         float nade_statuschange_elapsedtime;
1110         int total_ammo_count;
1111
1112         vector ammo_size;
1113         if (autocvar_hud_panel_ammo_onlycurrent)
1114                 total_ammo_count = 1;
1115         else
1116                 total_ammo_count = AMMO_COUNT;
1117
1118         if(draw_nades)
1119         {
1120                 ++total_ammo_count;
1121                 if (nade_cnt != nade_prevframe)
1122                 {
1123                         nade_statuschange_time = time;
1124                         nade_prevstatus = nade_prevframe;
1125                         nade_prevframe = nade_cnt;
1126                 }
1127         }
1128         else
1129                 nade_prevstatus = nade_prevframe = nade_statuschange_time = 0;
1130
1131         rows = HUD_GetRowCount(total_ammo_count, mySize, 3);
1132         columns = ceil((total_ammo_count)/rows);
1133         ammo_size = eX * mySize.x*(1/columns) + eY * mySize.y*(1/rows);
1134
1135         vector offset = '0 0 0'; // fteqcc sucks
1136         float newSize;
1137         if(ammo_size.x/ammo_size.y > 3)
1138         {
1139                 newSize = 3 * ammo_size.y;
1140                 offset.x = ammo_size.x - newSize;
1141                 pos.x += offset.x/2;
1142                 ammo_size.x = newSize;
1143         }
1144         else
1145         {
1146                 newSize = 1/3 * ammo_size.x;
1147                 offset.y = ammo_size.y - newSize;
1148                 pos.y += offset.y/2;
1149                 ammo_size.y = newSize;
1150         }
1151
1152         int i;
1153         bool infinite_ammo = (getstati(STAT_ITEMS, 0, 24) & IT_UNLIMITED_WEAPON_AMMO);
1154         row = column = 0;
1155         if(autocvar_hud_panel_ammo_onlycurrent)
1156         {
1157                 if(autocvar__hud_configure)
1158                 {
1159                         DrawAmmoItem(pos, ammo_size, ammo_rockets, true, false);
1160                 }
1161                 else
1162                 {
1163                         DrawAmmoItem(
1164                                 pos,
1165                                 ammo_size,
1166                                 (get_weaponinfo(switchweapon)).ammo_field,
1167                                 true,
1168                                 infinite_ammo
1169                         );
1170                 }
1171
1172                 ++row;
1173                 if(row >= rows)
1174                 {
1175                         row = 0;
1176                         column = column + 1;
1177                 }
1178         }
1179         else
1180         {
1181                 .int ammotype;
1182                 row = column = 0;
1183                 for(i = 0; i < AMMO_COUNT; ++i)
1184                 {
1185                         ammotype = GetAmmoFieldFromNum(i);
1186                         DrawAmmoItem(
1187                                 pos + eX * column * (ammo_size.x + offset.x) + eY * row * (ammo_size.y + offset.y),
1188                                 ammo_size,
1189                                 ammotype,
1190                                 ((get_weaponinfo(switchweapon)).ammo_field == ammotype),
1191                                 infinite_ammo
1192                         );
1193
1194                         ++row;
1195                         if(row >= rows)
1196                         {
1197                                 row = 0;
1198                                 column = column + 1;
1199                         }
1200                 }
1201         }
1202
1203         if (draw_nades)
1204         {
1205                 nade_statuschange_elapsedtime = time - nade_statuschange_time;
1206
1207                 float f = bound(0, nade_statuschange_elapsedtime*2, 1);
1208
1209                 DrawAmmoNades(pos + eX * column * (ammo_size.x + offset.x) + eY * row * (ammo_size.y + offset.y), ammo_size, nade_prevstatus < nade_cnt && nade_cnt != 0 && f < 1, f);
1210         }
1211
1212         draw_endBoldFont();
1213 }
1214
1215 void DrawNumIcon_expanding(vector myPos, vector mySize, float x, string icon, bool vertical, bool icon_right_align, vector color, float theAlpha, float fadelerp)
1216 {
1217         vector newPos = '0 0 0', newSize = '0 0 0';
1218         vector picpos, numpos;
1219
1220         if (vertical)
1221         {
1222                 if(mySize.y/mySize.x > 2)
1223                 {
1224                         newSize.y = 2 * mySize.x;
1225                         newSize.x = mySize.x;
1226
1227                         newPos.y = myPos.y + (mySize.y - newSize.y) / 2;
1228                         newPos.x = myPos.x;
1229                 }
1230                 else
1231                 {
1232                         newSize.x = 1/2 * mySize.y;
1233                         newSize.y = mySize.y;
1234
1235                         newPos.x = myPos.x + (mySize.x - newSize.x) / 2;
1236                         newPos.y = myPos.y;
1237                 }
1238
1239                 if(icon_right_align)
1240                 {
1241                         numpos = newPos;
1242                         picpos = newPos + eY * newSize.x;
1243                 }
1244                 else
1245                 {
1246                         picpos = newPos;
1247                         numpos = newPos + eY * newSize.x;
1248                 }
1249
1250                 newSize.y /= 2;
1251                 drawpic_aspect_skin(picpos, icon, newSize, '1 1 1', panel_fg_alpha * theAlpha, DRAWFLAG_NORMAL);
1252                 // make number smaller than icon, it looks better
1253                 // reduce only y to draw numbers with different number of digits with the same y size
1254                 numpos.y += newSize.y * ((1 - 0.7) / 2);
1255                 newSize.y *= 0.7;
1256                 drawstring_aspect(numpos, ftos(x), newSize, color, panel_fg_alpha * theAlpha, DRAWFLAG_NORMAL);
1257                 return;
1258         }
1259
1260         if(mySize.x/mySize.y > 3)
1261         {
1262                 newSize.x = 3 * mySize.y;
1263                 newSize.y = mySize.y;
1264
1265                 newPos.x = myPos.x + (mySize.x - newSize.x) / 2;
1266                 newPos.y = myPos.y;
1267         }
1268         else
1269         {
1270                 newSize.y = 1/3 * mySize.x;
1271                 newSize.x = mySize.x;
1272
1273                 newPos.y = myPos.y + (mySize.y - newSize.y) / 2;
1274                 newPos.x = myPos.x;
1275         }
1276
1277         if(icon_right_align) // right align
1278         {
1279                 numpos = newPos;
1280                 picpos = newPos + eX * 2 * newSize.y;
1281         }
1282         else // left align
1283         {
1284                 numpos = newPos + eX * newSize.y;
1285                 picpos = newPos;
1286         }
1287
1288         // NOTE: newSize_x is always equal to 3 * mySize_y so we can use
1289         // '2 1 0' * newSize_y instead of eX * (2/3) * newSize_x + eY * newSize_y
1290         drawstring_aspect_expanding(numpos, ftos(x), '2 1 0' * newSize.y, color, panel_fg_alpha * theAlpha, DRAWFLAG_NORMAL, fadelerp);
1291         drawpic_aspect_skin_expanding(picpos, icon, '1 1 0' * newSize.y, '1 1 1', panel_fg_alpha * theAlpha, DRAWFLAG_NORMAL, fadelerp);
1292 }
1293
1294 void DrawNumIcon(vector myPos, vector mySize, float x, string icon, bool vertical, bool icon_right_align, vector color, float theAlpha)
1295 {
1296         DrawNumIcon_expanding(myPos, mySize, x, icon, vertical, icon_right_align, color, theAlpha, 0);
1297 }
1298
1299 // Powerups (#2)
1300 //
1301 void HUD_Powerups(void)
1302 {
1303         float strength_time, shield_time, superweapons_time;
1304         if(!autocvar__hud_configure)
1305         {
1306                 if(!autocvar_hud_panel_powerups) return;
1307                 if(spectatee_status == -1) return;
1308                 if(!(getstati(STAT_ITEMS, 0, 24) & (IT_STRENGTH | IT_INVINCIBLE | IT_SUPERWEAPON))) return;
1309                 if (getstati(STAT_HEALTH) <= 0) return;
1310
1311                 strength_time = bound(0, getstatf(STAT_STRENGTH_FINISHED) - time, 99);
1312                 shield_time = bound(0, getstatf(STAT_INVINCIBLE_FINISHED) - time, 99);
1313                 superweapons_time = bound(0, getstatf(STAT_SUPERWEAPONS_FINISHED) - time, 99);
1314
1315                 if (getstati(STAT_ITEMS, 0, 24) & IT_UNLIMITED_SUPERWEAPONS)
1316                         superweapons_time = 99; // force max
1317
1318                 // prevent stuff to show up on mismatch that will be fixed next frame
1319                 if (!(getstati(STAT_ITEMS, 0, 24) & IT_SUPERWEAPON))
1320                         superweapons_time = 0;
1321         }
1322         else
1323         {
1324                 strength_time = 15;
1325                 shield_time = 27;
1326                 superweapons_time = 13;
1327         }
1328
1329         HUD_Panel_UpdateCvars();
1330
1331         draw_beginBoldFont();
1332
1333         vector pos, mySize;
1334         pos = panel_pos;
1335         mySize = panel_size;
1336
1337         HUD_Panel_DrawBg(bound(0, max(strength_time, shield_time, superweapons_time), 1));
1338         if(panel_bg_padding)
1339         {
1340                 pos += '1 1 0' * panel_bg_padding;
1341                 mySize -= '2 2 0' * panel_bg_padding;
1342         }
1343
1344         float panel_ar = mySize.x/mySize.y;
1345         bool is_vertical = (panel_ar < 1);
1346         vector shield_offset = '0 0 0', strength_offset = '0 0 0', superweapons_offset = '0 0 0';
1347
1348         int superweapons_is = -1;
1349
1350         if(superweapons_time)
1351         {
1352                 if(strength_time)
1353                 {
1354                         if(shield_time)
1355                                 superweapons_is = 0;
1356                         else
1357                                 superweapons_is = 2;
1358                 }
1359                 else
1360                 {
1361                         if(shield_time)
1362                                 superweapons_is = 1;
1363                         else
1364                                 superweapons_is = 2;
1365                 }
1366         }
1367
1368         // FIXME handle superweapons here
1369         if(superweapons_is == 0)
1370         {
1371                 if (panel_ar >= 4 || (panel_ar >= 1/4 && panel_ar < 1))
1372                 {
1373                         mySize.x *= (1.0 / 3.0);
1374                         superweapons_offset.x = mySize.x;
1375                         if (autocvar_hud_panel_powerups_flip)
1376                                 shield_offset.x = 2*mySize.x;
1377                         else
1378                                 strength_offset.x = 2*mySize.x;
1379                 }
1380                 else
1381                 {
1382                         mySize.y *= (1.0 / 3.0);
1383                         superweapons_offset.y = mySize.y;
1384                         if (autocvar_hud_panel_powerups_flip)
1385                                 shield_offset.y = 2*mySize.y;
1386                         else
1387                                 strength_offset.y = 2*mySize.y;
1388                 }
1389         }
1390         else
1391         {
1392                 if (panel_ar >= 4 || (panel_ar >= 1/4 && panel_ar < 1))
1393                 {
1394                         mySize.x *= 0.5;
1395                         if (autocvar_hud_panel_powerups_flip)
1396                                 shield_offset.x = mySize.x;
1397                         else
1398                                 strength_offset.x = mySize.x;
1399                 }
1400                 else
1401                 {
1402                         mySize.y *= 0.5;
1403                         if (autocvar_hud_panel_powerups_flip)
1404                                 shield_offset.y = mySize.y;
1405                         else
1406                                 strength_offset.y = mySize.y;
1407                 }
1408         }
1409
1410         bool shield_baralign, strength_baralign, superweapons_baralign;
1411         bool shield_iconalign, strength_iconalign, superweapons_iconalign;
1412
1413         if (autocvar_hud_panel_powerups_flip)
1414         {
1415                 strength_baralign = (autocvar_hud_panel_powerups_baralign == 2 || autocvar_hud_panel_powerups_baralign == 1);
1416                 shield_baralign = (autocvar_hud_panel_powerups_baralign == 3 || autocvar_hud_panel_powerups_baralign == 1);
1417                 strength_iconalign = (autocvar_hud_panel_powerups_iconalign == 2 || autocvar_hud_panel_powerups_iconalign == 1);
1418                 shield_iconalign = (autocvar_hud_panel_powerups_iconalign == 3 || autocvar_hud_panel_powerups_iconalign == 1);
1419         }
1420         else
1421         {
1422                 shield_baralign = (autocvar_hud_panel_powerups_baralign == 2 || autocvar_hud_panel_powerups_baralign == 1);
1423                 strength_baralign = (autocvar_hud_panel_powerups_baralign == 3 || autocvar_hud_panel_powerups_baralign == 1);
1424                 shield_iconalign = (autocvar_hud_panel_powerups_iconalign == 2 || autocvar_hud_panel_powerups_iconalign == 1);
1425                 strength_iconalign = (autocvar_hud_panel_powerups_iconalign == 3 || autocvar_hud_panel_powerups_iconalign == 1);
1426         }
1427
1428         if(superweapons_is == 0)
1429         {
1430                 superweapons_iconalign = strength_iconalign;
1431                 superweapons_baralign = 2;
1432         }
1433         else if(superweapons_is == 1)
1434         {
1435                 superweapons_offset = strength_offset;
1436                 superweapons_iconalign = strength_iconalign;
1437                 superweapons_baralign = strength_baralign;
1438         }
1439         else // if(superweapons_is == 2)
1440         {
1441                 superweapons_offset = shield_offset;
1442                 superweapons_iconalign = shield_iconalign;
1443                 superweapons_baralign = shield_baralign;
1444         }
1445
1446         if(shield_time)
1447         {
1448                 const float maxshield = 30;
1449                 float shield = ceil(shield_time);
1450                 if(autocvar_hud_panel_powerups_progressbar)
1451                         HUD_Panel_DrawProgressBar(pos + shield_offset, mySize, autocvar_hud_panel_powerups_progressbar_shield, shield/maxshield, is_vertical, shield_baralign, autocvar_hud_progressbar_shield_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
1452                 if(autocvar_hud_panel_powerups_text)
1453                 {
1454                         if(shield > 1)
1455                                 DrawNumIcon(pos + shield_offset, mySize, shield, "shield", is_vertical, shield_iconalign, '1 1 1', 1);
1456                         if(shield <= 5)
1457                                 DrawNumIcon_expanding(pos + shield_offset, mySize, shield, "shield", is_vertical, shield_iconalign, '1 1 1', 1, bound(0, (shield - shield_time) / 0.5, 1));
1458                 }
1459         }
1460
1461         if(strength_time)
1462         {
1463                 const float maxstrength = 30;
1464                 float strength = ceil(strength_time);
1465                 if(autocvar_hud_panel_powerups_progressbar)
1466                         HUD_Panel_DrawProgressBar(pos + strength_offset, mySize, autocvar_hud_panel_powerups_progressbar_strength, strength/maxstrength, is_vertical, strength_baralign, autocvar_hud_progressbar_strength_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
1467                 if(autocvar_hud_panel_powerups_text)
1468                 {
1469                         if(strength > 1)
1470                                 DrawNumIcon(pos + strength_offset, mySize, strength, "strength", is_vertical, strength_iconalign, '1 1 1', 1);
1471                         if(strength <= 5)
1472                                 DrawNumIcon_expanding(pos + strength_offset, mySize, strength, "strength", is_vertical, strength_iconalign, '1 1 1', 1, bound(0, (strength - strength_time) / 0.5, 1));
1473                 }
1474         }
1475
1476         if(superweapons_time)
1477         {
1478                 const float maxsuperweapons = 30;
1479                 float superweapons = ceil(superweapons_time);
1480                 if(autocvar_hud_panel_powerups_progressbar)
1481                         HUD_Panel_DrawProgressBar(pos + superweapons_offset, mySize, autocvar_hud_panel_powerups_progressbar_superweapons, superweapons/maxsuperweapons, is_vertical, superweapons_baralign, autocvar_hud_progressbar_superweapons_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
1482                 if(autocvar_hud_panel_powerups_text)
1483                 {
1484                         if(superweapons > 1)
1485                                 DrawNumIcon(pos + superweapons_offset, mySize, superweapons, "superweapons", is_vertical, superweapons_iconalign, '1 1 1', 1);
1486                         if(superweapons <= 5)
1487                                 DrawNumIcon_expanding(pos + superweapons_offset, mySize, superweapons, "superweapons", is_vertical, superweapons_iconalign, '1 1 1', 1, bound(0, (superweapons - superweapons_time) / 0.5, 1));
1488                 }
1489         }
1490
1491         draw_endBoldFont();
1492 }
1493
1494 // Health/armor (#3)
1495 //
1496
1497
1498 void HUD_HealthArmor(void)
1499 {
1500         int armor, health, fuel;
1501         if(!autocvar__hud_configure)
1502         {
1503                 if(!autocvar_hud_panel_healtharmor) return;
1504                 if(hud != HUD_NORMAL) return;
1505                 if(spectatee_status == -1) return;
1506
1507                 health = getstati(STAT_HEALTH);
1508                 if(health <= 0)
1509                 {
1510                         prev_health = -1;
1511                         return;
1512                 }
1513                 armor = getstati(STAT_ARMOR);
1514
1515                 // code to check for spectatee_status changes is in Ent_ClientData()
1516                 // prev_p_health and prev_health can be set to -1 there
1517
1518                 if (prev_p_health == -1)
1519                 {
1520                         // no effect
1521                         health_beforedamage = 0;
1522                         armor_beforedamage = 0;
1523                         health_damagetime = 0;
1524                         armor_damagetime = 0;
1525                         prev_health = health;
1526                         prev_armor = armor;
1527                         old_p_health = health;
1528                         old_p_armor = armor;
1529                         prev_p_health = health;
1530                         prev_p_armor = armor;
1531                 }
1532                 else if (prev_health == -1)
1533                 {
1534                         //start the load effect
1535                         health_damagetime = 0;
1536                         armor_damagetime = 0;
1537                         prev_health = 0;
1538                         prev_armor = 0;
1539                 }
1540                 fuel = getstati(STAT_FUEL);
1541         }
1542         else
1543         {
1544                 health = 150;
1545                 armor = 75;
1546                 fuel = 20;
1547         }
1548
1549         HUD_Panel_UpdateCvars();
1550
1551         draw_beginBoldFont();
1552
1553         vector pos, mySize;
1554         pos = panel_pos;
1555         mySize = panel_size;
1556
1557         HUD_Panel_DrawBg(1);
1558         if(panel_bg_padding)
1559         {
1560                 pos += '1 1 0' * panel_bg_padding;
1561                 mySize -= '2 2 0' * panel_bg_padding;
1562         }
1563
1564         int baralign = autocvar_hud_panel_healtharmor_baralign;
1565         int iconalign = autocvar_hud_panel_healtharmor_iconalign;
1566
1567     int maxhealth = autocvar_hud_panel_healtharmor_maxhealth;
1568     int maxarmor = autocvar_hud_panel_healtharmor_maxarmor;
1569         if(autocvar_hud_panel_healtharmor == 2) // combined health and armor display
1570         {
1571                 vector v;
1572                 v = healtharmor_maxdamage(health, armor, armorblockpercent, DEATH_WEAPON);
1573
1574                 float x;
1575                 x = floor(v.x + 1);
1576
1577         float maxtotal = maxhealth + maxarmor;
1578                 string biggercount;
1579                 if(v.z) // NOT fully armored
1580                 {
1581                         biggercount = "health";
1582                         if(autocvar_hud_panel_healtharmor_progressbar)
1583                                 HUD_Panel_DrawProgressBar(pos, mySize, autocvar_hud_panel_healtharmor_progressbar_health, x/maxtotal, 0, (baralign == 1 || baralign == 2), autocvar_hud_progressbar_health_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
1584                         if(armor)
1585             if(autocvar_hud_panel_healtharmor_text)
1586                                 drawpic_aspect_skin(pos + eX * mySize.x - eX * 0.5 * mySize.y, "armor", '0.5 0.5 0' * mySize.y, '1 1 1', panel_fg_alpha * armor / health, DRAWFLAG_NORMAL);
1587                 }
1588                 else
1589                 {
1590                         biggercount = "armor";
1591                         if(autocvar_hud_panel_healtharmor_progressbar)
1592                                 HUD_Panel_DrawProgressBar(pos, mySize, autocvar_hud_panel_healtharmor_progressbar_armor, x/maxtotal, 0, (baralign == 1 || baralign == 2), autocvar_hud_progressbar_armor_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
1593                         if(health)
1594             if(autocvar_hud_panel_healtharmor_text)
1595                                 drawpic_aspect_skin(pos + eX * mySize.x - eX * 0.5 * mySize.y, "health", '0.5 0.5 0' * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
1596                 }
1597         if(autocvar_hud_panel_healtharmor_text)
1598                         DrawNumIcon(pos, mySize, x, biggercount, 0, iconalign, HUD_Get_Num_Color(x, maxtotal), 1);
1599
1600                 if(fuel)
1601                         HUD_Panel_DrawProgressBar(pos, eX * mySize.x + eY * 0.2 * mySize.y, "progressbar", fuel/100, 0, (baralign == 1 || baralign == 3), autocvar_hud_progressbar_fuel_color, panel_fg_alpha * 0.8, DRAWFLAG_NORMAL);
1602         }
1603         else
1604         {
1605                 float panel_ar = mySize.x/mySize.y;
1606                 bool is_vertical = (panel_ar < 1);
1607                 vector health_offset = '0 0 0', armor_offset = '0 0 0';
1608                 if (panel_ar >= 4 || (panel_ar >= 1/4 && panel_ar < 1))
1609                 {
1610                         mySize.x *= 0.5;
1611                         if (autocvar_hud_panel_healtharmor_flip)
1612                                 health_offset.x = mySize.x;
1613                         else
1614                                 armor_offset.x = mySize.x;
1615                 }
1616                 else
1617                 {
1618                         mySize.y *= 0.5;
1619                         if (autocvar_hud_panel_healtharmor_flip)
1620                                 health_offset.y = mySize.y;
1621                         else
1622                                 armor_offset.y = mySize.y;
1623                 }
1624
1625                 bool health_baralign, armor_baralign, fuel_baralign;
1626                 bool health_iconalign, armor_iconalign;
1627                 if (autocvar_hud_panel_healtharmor_flip)
1628                 {
1629                         armor_baralign = (autocvar_hud_panel_healtharmor_baralign == 2 || autocvar_hud_panel_healtharmor_baralign == 1);
1630                         health_baralign = (autocvar_hud_panel_healtharmor_baralign == 3 || autocvar_hud_panel_healtharmor_baralign == 1);
1631                         fuel_baralign = health_baralign;
1632                         armor_iconalign = (autocvar_hud_panel_healtharmor_iconalign == 2 || autocvar_hud_panel_healtharmor_iconalign == 1);
1633                         health_iconalign = (autocvar_hud_panel_healtharmor_iconalign == 3 || autocvar_hud_panel_healtharmor_iconalign == 1);
1634                 }
1635                 else
1636                 {
1637                         health_baralign = (autocvar_hud_panel_healtharmor_baralign == 2 || autocvar_hud_panel_healtharmor_baralign == 1);
1638                         armor_baralign = (autocvar_hud_panel_healtharmor_baralign == 3 || autocvar_hud_panel_healtharmor_baralign == 1);
1639                         fuel_baralign = armor_baralign;
1640                         health_iconalign = (autocvar_hud_panel_healtharmor_iconalign == 2 || autocvar_hud_panel_healtharmor_iconalign == 1);
1641                         armor_iconalign = (autocvar_hud_panel_healtharmor_iconalign == 3 || autocvar_hud_panel_healtharmor_iconalign == 1);
1642                 }
1643
1644                 //if(health)
1645                 {
1646                         if(autocvar_hud_panel_healtharmor_progressbar)
1647                         {
1648                                 float p_health, pain_health_alpha;
1649                                 p_health = health;
1650                                 pain_health_alpha = 1;
1651                                 if (autocvar_hud_panel_healtharmor_progressbar_gfx)
1652                                 {
1653                                         if (autocvar_hud_panel_healtharmor_progressbar_gfx_smooth > 0)
1654                                         {
1655                                                 if (fabs(prev_health - health) >= autocvar_hud_panel_healtharmor_progressbar_gfx_smooth)
1656                                                 {
1657                                                         if (time - old_p_healthtime < 1)
1658                                                                 old_p_health = prev_p_health;
1659                                                         else
1660                                                                 old_p_health = prev_health;
1661                                                         old_p_healthtime = time;
1662                                                 }
1663                                                 if (time - old_p_healthtime < 1)
1664                                                 {
1665                                                         p_health += (old_p_health - health) * (1 - (time - old_p_healthtime));
1666                                                         prev_p_health = p_health;
1667                                                 }
1668                                         }
1669                                         if (autocvar_hud_panel_healtharmor_progressbar_gfx_damage > 0)
1670                                         {
1671                                                 if (prev_health - health >= autocvar_hud_panel_healtharmor_progressbar_gfx_damage)
1672                                                 {
1673                                                         if (time - health_damagetime >= 1)
1674                                                                 health_beforedamage = prev_health;
1675                                                         health_damagetime = time;
1676                                                 }
1677                                                 if (time - health_damagetime < 1)
1678                                                 {
1679                                                         float health_damagealpha = 1 - (time - health_damagetime)*(time - health_damagetime);
1680                                                         HUD_Panel_DrawProgressBar(pos + health_offset, mySize, autocvar_hud_panel_healtharmor_progressbar_health, health_beforedamage/maxhealth, is_vertical, health_baralign, autocvar_hud_progressbar_health_color, autocvar_hud_progressbar_alpha * panel_fg_alpha * health_damagealpha, DRAWFLAG_NORMAL);
1681                                                 }
1682                                         }
1683                                         prev_health = health;
1684
1685                                         if (health <= autocvar_hud_panel_healtharmor_progressbar_gfx_lowhealth)
1686                                         {
1687                                                 float BLINK_FACTOR = 0.15;
1688                                                 float BLINK_BASE = 0.85;
1689                                                 float BLINK_FREQ = 9;
1690                                                 pain_health_alpha = BLINK_BASE + BLINK_FACTOR * cos(time * BLINK_FREQ);
1691                                         }
1692                                 }
1693                                 HUD_Panel_DrawProgressBar(pos + health_offset, mySize, autocvar_hud_panel_healtharmor_progressbar_health, p_health/maxhealth, is_vertical, health_baralign, autocvar_hud_progressbar_health_color, autocvar_hud_progressbar_alpha * panel_fg_alpha * pain_health_alpha, DRAWFLAG_NORMAL);
1694                         }
1695                         if(autocvar_hud_panel_healtharmor_text)
1696                                 DrawNumIcon(pos + health_offset, mySize, health, "health", is_vertical, health_iconalign, HUD_Get_Num_Color(health, maxhealth), 1);
1697                 }
1698
1699                 if(armor)
1700                 {
1701                         if(autocvar_hud_panel_healtharmor_progressbar)
1702                         {
1703                                 float p_armor;
1704                                 p_armor = armor;
1705                                 if (autocvar_hud_panel_healtharmor_progressbar_gfx)
1706                                 {
1707                                         if (autocvar_hud_panel_healtharmor_progressbar_gfx_smooth > 0)
1708                                         {
1709                                                 if (fabs(prev_armor - armor) >= autocvar_hud_panel_healtharmor_progressbar_gfx_smooth)
1710                                                 {
1711                                                         if (time - old_p_armortime < 1)
1712                                                                 old_p_armor = prev_p_armor;
1713                                                         else
1714                                                                 old_p_armor = prev_armor;
1715                                                         old_p_armortime = time;
1716                                                 }
1717                                                 if (time - old_p_armortime < 1)
1718                                                 {
1719                                                         p_armor += (old_p_armor - armor) * (1 - (time - old_p_armortime));
1720                                                         prev_p_armor = p_armor;
1721                                                 }
1722                                         }
1723                                         if (autocvar_hud_panel_healtharmor_progressbar_gfx_damage > 0)
1724                                         {
1725                                                 if (prev_armor - armor >= autocvar_hud_panel_healtharmor_progressbar_gfx_damage)
1726                                                 {
1727                                                         if (time - armor_damagetime >= 1)
1728                                                                 armor_beforedamage = prev_armor;
1729                                                         armor_damagetime = time;
1730                                                 }
1731                                                 if (time - armor_damagetime < 1)
1732                                                 {
1733                                                         float armor_damagealpha = 1 - (time - armor_damagetime)*(time - armor_damagetime);
1734                                                         HUD_Panel_DrawProgressBar(pos + armor_offset, mySize, autocvar_hud_panel_healtharmor_progressbar_armor, armor_beforedamage/maxarmor, is_vertical, armor_baralign, autocvar_hud_progressbar_armor_color, autocvar_hud_progressbar_alpha * panel_fg_alpha * armor_damagealpha, DRAWFLAG_NORMAL);
1735                                                 }
1736                                         }
1737                                         prev_armor = armor;
1738                                 }
1739                                 HUD_Panel_DrawProgressBar(pos + armor_offset, mySize, autocvar_hud_panel_healtharmor_progressbar_armor, p_armor/maxarmor, is_vertical, armor_baralign, autocvar_hud_progressbar_armor_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
1740                         }
1741                         if(autocvar_hud_panel_healtharmor_text)
1742                                 DrawNumIcon(pos + armor_offset, mySize, armor, "armor", is_vertical, armor_iconalign, HUD_Get_Num_Color(armor, maxarmor), 1);
1743                 }
1744
1745                 if(fuel)
1746                 {
1747                         if (is_vertical)
1748                                 mySize.x *= 0.2 / 2; //if vertical always halve x to not cover too much numbers with 3 digits
1749                         else
1750                                 mySize.y *= 0.2;
1751                         if (panel_ar >= 4)
1752                                 mySize.x *= 2; //restore full panel size
1753                         else if (panel_ar < 1/4)
1754                                 mySize.y *= 2; //restore full panel size
1755                         HUD_Panel_DrawProgressBar(pos, mySize, "progressbar", fuel/100, is_vertical, fuel_baralign, autocvar_hud_progressbar_fuel_color, panel_fg_alpha * 0.8, DRAWFLAG_NORMAL);
1756                 }
1757         }
1758
1759         draw_endBoldFont();
1760 }
1761
1762 // Notification area (#4)
1763 //
1764
1765 void HUD_Notify_Push(string icon, string attacker, string victim)
1766 {
1767         if (icon == "")
1768                 return;
1769
1770         ++notify_count;
1771         --notify_index;
1772
1773         if (notify_index == -1)
1774                 notify_index = NOTIFY_MAX_ENTRIES-1;
1775
1776         // Free old strings
1777         if (notify_attackers[notify_index])
1778                 strunzone(notify_attackers[notify_index]);
1779
1780         if (notify_victims[notify_index])
1781                 strunzone(notify_victims[notify_index]);
1782
1783         if (notify_icons[notify_index])
1784                 strunzone(notify_icons[notify_index]);
1785
1786         // Allocate new strings
1787         if (victim != "")
1788         {
1789                 notify_attackers[notify_index] = strzone(attacker);
1790                 notify_victims[notify_index] = strzone(victim);
1791         }
1792         else
1793         {
1794                 // In case of a notification without a victim, the attacker
1795                 // is displayed on the victim's side. Instead of special
1796                 // treatment later on, we can simply switch them here.
1797                 notify_attackers[notify_index] = string_null;
1798                 notify_victims[notify_index] = strzone(attacker);
1799         }
1800
1801         notify_icons[notify_index] = strzone(icon);
1802         notify_times[notify_index] = time;
1803 }
1804
1805 void HUD_Notify(void)
1806 {
1807         if (!autocvar__hud_configure)
1808                 if (!autocvar_hud_panel_notify)
1809                         return;
1810
1811         HUD_Panel_UpdateCvars();
1812         HUD_Panel_DrawBg(1);
1813
1814         if (!autocvar__hud_configure)
1815                 if (notify_count == 0)
1816                         return;
1817
1818         vector pos, size;
1819         pos  = panel_pos;
1820         size = panel_size;
1821
1822         if (panel_bg_padding)
1823         {
1824                 pos  += '1 1 0' * panel_bg_padding;
1825                 size -= '2 2 0' * panel_bg_padding;
1826         }
1827
1828         float fade_start = max(0, autocvar_hud_panel_notify_time);
1829         float fade_time = max(0, autocvar_hud_panel_notify_fadetime);
1830         float icon_aspect = max(1, autocvar_hud_panel_notify_icon_aspect);
1831
1832         int entry_count = bound(1, floor(NOTIFY_MAX_ENTRIES * size.y / size.x), NOTIFY_MAX_ENTRIES);
1833         float entry_height = size.y / entry_count;
1834
1835         float panel_width_half = size.x * 0.5;
1836         float icon_width_half = entry_height * icon_aspect / 2;
1837         float name_maxwidth = panel_width_half - icon_width_half - size.x * NOTIFY_ICON_MARGIN;
1838
1839         vector font_size = '0.5 0.5 0' * entry_height * autocvar_hud_panel_notify_fontsize;
1840         vector icon_size = (eX * icon_aspect + eY) * entry_height;
1841         vector icon_left = eX * (panel_width_half - icon_width_half);
1842         vector attacker_right = eX * name_maxwidth;
1843         vector victim_left = eX * (size.x - name_maxwidth);
1844
1845         vector attacker_pos, victim_pos, icon_pos;
1846         string attacker, victim, icon;
1847         int i, j, count, step, limit;
1848         float alpha;
1849
1850         if (autocvar_hud_panel_notify_flip)
1851         {
1852                 // Order items from the top down
1853                 i = 0;
1854                 step = +1;
1855                 limit = entry_count;
1856         }
1857         else
1858         {
1859                 // Order items from the bottom up
1860                 i = entry_count - 1;
1861                 step = -1;
1862                 limit = -1;
1863         }
1864
1865         for (j = notify_index, count = 0; i != limit; i += step, ++j, ++count)
1866         {
1867                 if(autocvar__hud_configure)
1868                 {
1869                         attacker = sprintf(_("Player %d"), count + 1);
1870                         victim = sprintf(_("Player %d"), count + 2);
1871                         icon = get_weaponinfo(min(WEP_FIRST + count * 2, WEP_LAST)).model2;
1872                         alpha = bound(0, 1.2 - count / entry_count, 1);
1873                 }
1874                 else
1875                 {
1876                         if (j == NOTIFY_MAX_ENTRIES)
1877                                 j = 0;
1878
1879                         if (notify_times[j] + fade_start > time)
1880                                 alpha = 1;
1881                         else if (fade_time != 0)
1882                         {
1883                                 alpha = bound(0, (notify_times[j] + fade_start + fade_time - time) / fade_time, 1);
1884                                 if (alpha == 0)
1885                                         break;
1886                         }
1887                         else
1888                                 break;
1889
1890                         attacker = notify_attackers[j];
1891                         victim = notify_victims[j];
1892                         icon = notify_icons[j];
1893                 }
1894
1895                 if (icon != "" && victim != "")
1896                 {
1897                         vector name_top = eY * (i * entry_height + 0.5 * (entry_height - font_size.y));
1898
1899                         icon_pos = pos + icon_left + eY * i * entry_height;
1900                         drawpic_aspect_skin(icon_pos, icon, icon_size, '1 1 1', panel_fg_alpha * alpha, DRAWFLAG_NORMAL);
1901
1902                         victim = textShortenToWidth(victim, name_maxwidth, font_size, stringwidth_colors);
1903                         victim_pos = pos + victim_left + name_top;
1904                         drawcolorcodedstring(victim_pos, victim, font_size, panel_fg_alpha * alpha, DRAWFLAG_NORMAL);
1905
1906                         if (attacker != "")
1907                         {
1908                                 attacker = textShortenToWidth(attacker, name_maxwidth, font_size, stringwidth_colors);
1909                                 attacker_pos = pos + attacker_right - eX * stringwidth(attacker, true, font_size) + name_top;
1910                                 drawcolorcodedstring(attacker_pos, attacker, font_size, panel_fg_alpha * alpha, DRAWFLAG_NORMAL);
1911                         }
1912                 }
1913         }
1914
1915         notify_count = count;
1916 }
1917
1918 // Timer (#5)
1919 //
1920 // TODO: macro
1921 string seconds_tostring(float sec)
1922 {
1923         float minutes;
1924         minutes = floor(sec / 60);
1925
1926         sec -= minutes * 60;
1927         return sprintf("%d:%02d", minutes, sec);
1928 }
1929
1930 void HUD_Timer(void)
1931 {
1932         if(!autocvar__hud_configure)
1933         {
1934                 if(!autocvar_hud_panel_timer) return;
1935         }
1936
1937         HUD_Panel_UpdateCvars();
1938
1939         draw_beginBoldFont();
1940
1941         vector pos, mySize;
1942         pos = panel_pos;
1943         mySize = panel_size;
1944
1945         HUD_Panel_DrawBg(1);
1946         if(panel_bg_padding)
1947         {
1948                 pos += '1 1 0' * panel_bg_padding;
1949                 mySize -= '2 2 0' * panel_bg_padding;
1950         }
1951
1952         string timer;
1953         float timelimit, elapsedTime, timeleft, minutesLeft;
1954
1955         timelimit = getstatf(STAT_TIMELIMIT);
1956
1957         timeleft = max(0, timelimit * 60 + getstatf(STAT_GAMESTARTTIME) - time);
1958         timeleft = ceil(timeleft);
1959
1960         minutesLeft = floor(timeleft / 60);
1961
1962         vector timer_color;
1963         if(minutesLeft >= 5 || warmup_stage || timelimit == 0) //don't use red or yellow in warmup or when there is no timelimit
1964                 timer_color = '1 1 1'; //white
1965         else if(minutesLeft >= 1)
1966                 timer_color = '1 1 0'; //yellow
1967         else
1968                 timer_color = '1 0 0'; //red
1969
1970         if (autocvar_hud_panel_timer_increment || timelimit == 0 || warmup_stage) {
1971                 if (time < getstatf(STAT_GAMESTARTTIME)) {
1972                         //while restart is still active, show 00:00
1973                         timer = seconds_tostring(0);
1974                 } else {
1975                         elapsedTime = floor(time - getstatf(STAT_GAMESTARTTIME)); //127
1976                         timer = seconds_tostring(elapsedTime);
1977                 }
1978         } else {
1979                 timer = seconds_tostring(timeleft);
1980         }
1981
1982         drawstring_aspect(pos, timer, mySize, timer_color, panel_fg_alpha, DRAWFLAG_NORMAL);
1983
1984         draw_endBoldFont();
1985 }
1986
1987 // Radar (#6)
1988 //
1989 void HUD_Radar(void)
1990 {
1991         if (!autocvar__hud_configure)
1992         {
1993                 if (hud_panel_radar_maximized)
1994                 {
1995                         if (!hud_draw_maximized) return;
1996                 }
1997                 else
1998                 {
1999                         if (autocvar_hud_panel_radar == 0) return;
2000                         if (autocvar_hud_panel_radar != 2 && !teamplay) return;
2001                         if(radar_panel_modified)
2002                         {
2003                                 panel.update_time = time; // forces reload of panel attributes
2004                                 radar_panel_modified = false;
2005                         }
2006                 }
2007         }
2008
2009         HUD_Panel_UpdateCvars();
2010
2011         float f = 0;
2012
2013         if (hud_panel_radar_maximized && !autocvar__hud_configure)
2014         {
2015                 panel_size = autocvar_hud_panel_radar_maximized_size;
2016                 panel_size.x = bound(0.2, panel_size.x, 1) * vid_conwidth;
2017                 panel_size.y = bound(0.2, panel_size.y, 1) * vid_conheight;
2018                 panel_pos.x = (vid_conwidth - panel_size.x) / 2;
2019                 panel_pos.y = (vid_conheight - panel_size.y) / 2;
2020
2021                 string panel_bg;
2022                 panel_bg = strcat(hud_skin_path, "/border_default"); // always use the default border when maximized
2023                 if(precache_pic(panel_bg) == "")
2024                         panel_bg = "gfx/hud/default/border_default"; // fallback
2025                 if(!radar_panel_modified && panel_bg != panel.current_panel_bg)
2026                         radar_panel_modified = true;
2027                 if(panel.current_panel_bg)
2028                         strunzone(panel.current_panel_bg);
2029                 panel.current_panel_bg = strzone(panel_bg);
2030
2031                 switch(hud_panel_radar_maximized_zoommode)
2032                 {
2033                         default:
2034                         case 0:
2035                                 f = current_zoomfraction;
2036                                 break;
2037                         case 1:
2038                                 f = 1 - current_zoomfraction;
2039                                 break;
2040                         case 2:
2041                                 f = 0;
2042                                 break;
2043                         case 3:
2044                                 f = 1;
2045                                 break;
2046                 }
2047
2048                 switch(hud_panel_radar_maximized_rotation)
2049                 {
2050                         case 0:
2051                                 teamradar_angle = view_angles.y - 90;
2052                                 break;
2053                         default:
2054                                 teamradar_angle = 90 * hud_panel_radar_maximized_rotation;
2055                                 break;
2056                 }
2057         }
2058         if (!hud_panel_radar_maximized && !autocvar__hud_configure)
2059         {
2060                 switch(hud_panel_radar_zoommode)
2061                 {
2062                         default:
2063                         case 0:
2064                                 f = current_zoomfraction;
2065                                 break;
2066                         case 1:
2067                                 f = 1 - current_zoomfraction;
2068                                 break;
2069                         case 2:
2070                                 f = 0;
2071                                 break;
2072                         case 3:
2073                                 f = 1;
2074                                 break;
2075                 }
2076
2077                 switch(hud_panel_radar_rotation)
2078                 {
2079                         case 0:
2080                                 teamradar_angle = view_angles.y - 90;
2081                                 break;
2082                         default:
2083                                 teamradar_angle = 90 * hud_panel_radar_rotation;
2084                                 break;
2085                 }
2086         }
2087
2088         vector pos, mySize;
2089         pos = panel_pos;
2090         mySize = panel_size;
2091
2092         HUD_Panel_DrawBg(1);
2093         if(panel_bg_padding)
2094         {
2095                 pos += '1 1 0' * panel_bg_padding;
2096                 mySize -= '2 2 0' * panel_bg_padding;
2097         }
2098
2099         int color2;
2100         entity tm;
2101         float scale2d, normalsize, bigsize;
2102
2103         teamradar_origin2d = pos + 0.5 * mySize;
2104         teamradar_size2d = mySize;
2105
2106         if(minimapname == "")
2107                 return;
2108
2109         teamradar_loadcvars();
2110
2111         scale2d = vlen_maxnorm2d(mi_picmax - mi_picmin);
2112         teamradar_size2d = mySize;
2113
2114         teamradar_extraclip_mins = teamradar_extraclip_maxs = '0 0 0'; // we always center
2115
2116         // pixels per world qu to match the teamradar_size2d_x range in the longest dimension
2117         if((hud_panel_radar_rotation == 0 && !hud_panel_radar_maximized) || (hud_panel_radar_maximized_rotation == 0 && hud_panel_radar_maximized))
2118         {
2119                 // max-min distance must fit the radar in any rotation
2120                 bigsize = vlen_minnorm2d(teamradar_size2d) * scale2d / (1.05 * vlen2d(mi_scale));
2121         }
2122         else
2123         {
2124                 vector c0, c1, c2, c3, span;
2125                 c0 = rotate(mi_min, teamradar_angle * DEG2RAD);
2126                 c1 = rotate(mi_max, teamradar_angle * DEG2RAD);
2127                 c2 = rotate('1 0 0' * mi_min.x + '0 1 0' * mi_max.y, teamradar_angle * DEG2RAD);
2128                 c3 = rotate('1 0 0' * mi_max.x + '0 1 0' * mi_min.y, teamradar_angle * DEG2RAD);
2129                 span = '0 0 0';
2130                 span.x = max(c0_x, c1_x, c2_x, c3_x) - min(c0_x, c1_x, c2_x, c3_x);
2131                 span.y = max(c0_y, c1_y, c2_y, c3_y) - min(c0_y, c1_y, c2_y, c3_y);
2132
2133                 // max-min distance must fit the radar in x=x, y=y
2134                 bigsize = min(
2135                         teamradar_size2d.x * scale2d / (1.05 * span.x),
2136                         teamradar_size2d.y * scale2d / (1.05 * span.y)
2137                 );
2138         }
2139
2140         normalsize = vlen_maxnorm2d(teamradar_size2d) * scale2d / hud_panel_radar_scale;
2141         if(bigsize > normalsize)
2142                 normalsize = bigsize;
2143
2144         teamradar_size =
2145                   f * bigsize
2146                 + (1 - f) * normalsize;
2147         teamradar_origin3d_in_texcoord = teamradar_3dcoord_to_texcoord(
2148                   f * mi_center
2149                 + (1 - f) * view_origin);
2150
2151         drawsetcliparea(
2152                 pos.x,
2153                 pos.y,
2154                 mySize.x,
2155                 mySize.y
2156         );
2157
2158         draw_teamradar_background(hud_panel_radar_foreground_alpha);
2159
2160         for(tm = world; (tm = find(tm, classname, "radarlink")); )
2161                 draw_teamradar_link(tm.origin, tm.velocity, tm.team);
2162         for(tm = world; (tm = findflags(tm, teamradar_icon, 0xFFFFFF)); )
2163                 draw_teamradar_icon(tm.origin, tm.teamradar_icon, tm, tm.teamradar_color, panel_fg_alpha);
2164         for(tm = world; (tm = find(tm, classname, "entcs_receiver")); )
2165         {
2166                 color2 = GetPlayerColor(tm.sv_entnum);
2167                 //if(color == NUM_SPECTATOR || color == color2)
2168                         draw_teamradar_player(tm.origin, tm.angles, Team_ColorRGB(color2));
2169         }
2170         draw_teamradar_player(view_origin, view_angles, '1 1 1');
2171
2172         drawresetcliparea();
2173 }
2174
2175 // Score (#7)
2176 //
2177 void HUD_UpdatePlayerTeams();
2178 void HUD_Score_Rankings(vector pos, vector mySize, entity me)
2179 {
2180         float score;
2181         entity tm = world, pl;
2182         int SCOREPANEL_MAX_ENTRIES = 6;
2183         float SCOREPANEL_ASPECTRATIO = 2;
2184         int entries = bound(1, floor(SCOREPANEL_MAX_ENTRIES * mySize.y/mySize.x * SCOREPANEL_ASPECTRATIO), SCOREPANEL_MAX_ENTRIES);
2185         vector fontsize = '1 1 0' * (mySize.y/entries);
2186
2187         vector rgb, score_color;
2188         rgb = '1 1 1';
2189         score_color = '1 1 1';
2190
2191         float name_size = mySize.x*0.75;
2192         float spacing_size = mySize.x*0.04;
2193         const float highlight_alpha = 0.2;
2194         int i = 0, first_pl = 0;
2195         bool me_printed = false;
2196         string s;
2197         if (autocvar__hud_configure)
2198         {
2199                 float players_per_team = 0;
2200                 if (team_count)
2201                 {
2202                         // show team scores in the first line
2203                         float score_size = mySize.x / team_count;
2204                         players_per_team = max(2, ceil((entries - 1) / team_count));
2205                         for(i=0; i<team_count; ++i) {
2206                                 if (i == floor((entries - 2) / players_per_team) || (entries == 1 && i == 0))
2207                                         HUD_Panel_DrawHighlight(pos + eX * score_size * i, eX * score_size + eY * fontsize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2208                                 drawstring_aspect(pos + eX * score_size * i, ftos(175 - 23*i), eX * score_size + eY * fontsize.y, Team_ColorRGB(ColorByTeam(i)) * 0.8, panel_fg_alpha, DRAWFLAG_NORMAL);
2209                         }
2210                         first_pl = 1;
2211                         pos.y += fontsize.y;
2212                 }
2213                 score = 10 + SCOREPANEL_MAX_ENTRIES * 3;
2214                 for (i=first_pl; i<entries; ++i)
2215                 {
2216                         //simulate my score is lower than all displayed players,
2217                         //so that I don't appear at all showing pure rankings.
2218                         //This is to better show the difference between the 2 ranking views
2219                         if (i == entries-1 && autocvar_hud_panel_score_rankings == 1)
2220                         {
2221                                 rgb = '1 1 0';
2222                                 drawfill(pos, eX * mySize.x + eY * fontsize.y, rgb, highlight_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2223                                 s = GetPlayerName(player_localnum);
2224                                 score = 7;
2225                         }
2226                         else
2227                         {
2228                                 s = sprintf(_("Player %d"), i + 1 - first_pl);
2229                                 score -= 3;
2230                         }
2231
2232                         if (team_count)
2233                                 score_color = Team_ColorRGB(ColorByTeam(floor((i - first_pl) / players_per_team))) * 0.8;
2234                         s = textShortenToWidth(s, name_size, fontsize, stringwidth_colors);
2235                         drawcolorcodedstring(pos + eX * (name_size - stringwidth(s, true, fontsize)), s, fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
2236                         drawstring(pos + eX * (name_size + spacing_size), ftos(score), fontsize, score_color, panel_fg_alpha, DRAWFLAG_NORMAL);
2237                         pos.y += fontsize.y;
2238                 }
2239                 return;
2240         }
2241
2242         if (!scoreboard_fade_alpha) // the scoreboard too calls HUD_UpdatePlayerTeams
2243                 HUD_UpdatePlayerTeams();
2244         if (team_count)
2245         {
2246                 // show team scores in the first line
2247                 float score_size = mySize.x / team_count;
2248                 for(tm = teams.sort_next; tm; tm = tm.sort_next) {
2249                         if(tm.team == NUM_SPECTATOR)
2250                                 continue;
2251                         if (tm.team == myteam)
2252                                 drawfill(pos + eX * score_size * i, eX * score_size + eY * fontsize.y, '1 1 1', highlight_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2253                         drawstring_aspect(pos + eX * score_size * i, ftos(tm.(teamscores[ts_primary])), eX * score_size + eY * fontsize.y, Team_ColorRGB(tm.team) * 0.8, panel_fg_alpha, DRAWFLAG_NORMAL);
2254                         ++i;
2255                 }
2256                 first_pl = 1;
2257                 pos.y += fontsize.y;
2258                 tm = teams.sort_next;
2259         }
2260         i = first_pl;
2261
2262         do
2263         for (pl = players.sort_next; pl && i<entries; pl = pl.sort_next)
2264         {
2265                 if ((team_count && pl.team != tm.team) || pl.team == NUM_SPECTATOR)
2266                         continue;
2267
2268                 if (i == entries-1 && !me_printed && pl != me)
2269                 if (autocvar_hud_panel_score_rankings == 1 && spectatee_status != -1)
2270                 {
2271                         for (pl = me.sort_next; pl; pl = pl.sort_next)
2272                                 if (pl.team != NUM_SPECTATOR)
2273                                         break;
2274
2275                         if (pl)
2276                                 rgb = '1 1 0'; //not last but not among the leading players: yellow
2277                         else
2278                                 rgb = '1 0 0'; //last: red
2279                         pl = me;
2280                 }
2281
2282                 if (pl == me)
2283                 {
2284                         if (i == first_pl)
2285                                 rgb = '0 1 0'; //first: green
2286                         me_printed = true;
2287                         drawfill(pos, eX * mySize.x + eY * fontsize.y, rgb, highlight_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2288                 }
2289                 if (team_count)
2290                         score_color = Team_ColorRGB(pl.team) * 0.8;
2291                 s = textShortenToWidth(GetPlayerName(pl.sv_entnum), name_size, fontsize, stringwidth_colors);
2292                 drawcolorcodedstring(pos + eX * (name_size - stringwidth(s, true, fontsize)), s, fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
2293                 drawstring(pos + eX * (name_size + spacing_size), ftos(pl.(scores[ps_primary])), fontsize, score_color, panel_fg_alpha, DRAWFLAG_NORMAL);
2294                 pos.y += fontsize.y;
2295                 ++i;
2296         }
2297         while (i<entries && team_count && (tm = tm.sort_next) && (tm.team != NUM_SPECTATOR || (tm = tm.sort_next)));
2298 }
2299
2300 void HUD_Score(void)
2301 {
2302         if(!autocvar__hud_configure)
2303         {
2304                 if(!autocvar_hud_panel_score) return;
2305                 if(spectatee_status == -1 && (gametype == MAPINFO_TYPE_RACE || gametype == MAPINFO_TYPE_CTS)) return;
2306         }
2307
2308         HUD_Panel_UpdateCvars();
2309         vector pos, mySize;
2310         pos = panel_pos;
2311         mySize = panel_size;
2312
2313         HUD_Panel_DrawBg(1);
2314         if(panel_bg_padding)
2315         {
2316                 pos += '1 1 0' * panel_bg_padding;
2317                 mySize -= '2 2 0' * panel_bg_padding;
2318         }
2319
2320         float score, distribution = 0;
2321         string sign;
2322         vector distribution_color;
2323         entity tm, pl, me;
2324
2325         me = playerslots[current_player];
2326
2327         if((scores_flags[ps_primary] & SFL_TIME) && !teamplay) { // race/cts record display on HUD
2328                 string timer, distrtimer;
2329
2330                 pl = players.sort_next;
2331                 if(pl == me)
2332                         pl = pl.sort_next;
2333                 if(scores_flags[ps_primary] & SFL_ZERO_IS_WORST)
2334                         if(pl.scores[ps_primary] == 0)
2335                                 pl = world;
2336
2337                 score = me.(scores[ps_primary]);
2338                 timer = TIME_ENCODED_TOSTRING(score);
2339
2340                 draw_beginBoldFont();
2341                 if (pl && ((!(scores_flags[ps_primary] & SFL_ZERO_IS_WORST)) || score)) {
2342                         // distribution display
2343                         distribution = me.(scores[ps_primary]) - pl.(scores[ps_primary]);
2344
2345                         distrtimer = ftos_decimals(fabs(distribution/pow(10, TIME_DECIMALS)), TIME_DECIMALS);
2346
2347                         if (distribution <= 0) {
2348                                 distribution_color = '0 1 0';
2349                                 sign = "-";
2350                         }
2351                         else {
2352                                 distribution_color = '1 0 0';
2353                                 sign = "+";
2354                         }
2355                         drawstring_aspect(pos + eX * 0.75 * mySize.x, strcat(sign, distrtimer), eX * 0.25 * mySize.x + eY * (1/3) * mySize.y, distribution_color, panel_fg_alpha, DRAWFLAG_NORMAL);
2356                 }
2357                 // race record display
2358                 if (distribution <= 0)
2359                         HUD_Panel_DrawHighlight(pos, eX * 0.75 * mySize.x + eY * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2360                 drawstring_aspect(pos, timer, eX * 0.75 * mySize.x + eY * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2361                 draw_endBoldFont();
2362         } else if (!teamplay) { // non-teamgames
2363                 if ((spectatee_status == -1 && !autocvar__hud_configure) || autocvar_hud_panel_score_rankings)
2364                 {
2365                         HUD_Score_Rankings(pos, mySize, me);
2366                         return;
2367                 }
2368                 // me vector := [team/connected frags id]
2369                 pl = players.sort_next;
2370                 if(pl == me)
2371                         pl = pl.sort_next;
2372
2373                 if(autocvar__hud_configure)
2374                         distribution = 42;
2375                 else if(pl)
2376                         distribution = me.(scores[ps_primary]) - pl.(scores[ps_primary]);
2377                 else
2378                         distribution = 0;
2379
2380                 score = me.(scores[ps_primary]);
2381                 if(autocvar__hud_configure)
2382                         score = 123;
2383
2384                 if(distribution >= 5)
2385                         distribution_color = eY;
2386                 else if(distribution >= 0)
2387                         distribution_color = '1 1 1';
2388                 else if(distribution >= -5)
2389                         distribution_color = '1 1 0';
2390                 else
2391                         distribution_color = eX;
2392
2393                 string distribution_str;
2394                 distribution_str = ftos(distribution);
2395                 draw_beginBoldFont();
2396                 if (distribution >= 0)
2397                 {
2398                         if (distribution > 0)
2399                                 distribution_str = strcat("+", distribution_str);
2400                         HUD_Panel_DrawHighlight(pos, eX * 0.75 * mySize.x + eY * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2401                 }
2402                 drawstring_aspect(pos, ftos(score), eX * 0.75 * mySize.x + eY * mySize.y, distribution_color, panel_fg_alpha, DRAWFLAG_NORMAL);
2403                 drawstring_aspect(pos + eX * 0.75 * mySize.x, distribution_str, eX * 0.25 * mySize.x + eY * (1/3) * mySize.y, distribution_color, panel_fg_alpha, DRAWFLAG_NORMAL);
2404                 draw_endBoldFont();
2405         } else { // teamgames
2406                 float row, column, rows = 0, columns = 0;
2407                 vector offset = '0 0 0';
2408                 vector score_pos, score_size; //for scores other than myteam
2409                 if(autocvar_hud_panel_score_rankings)
2410                 {
2411                         HUD_Score_Rankings(pos, mySize, me);
2412                         return;
2413                 }
2414                 if(spectatee_status == -1)
2415                 {
2416                         rows = HUD_GetRowCount(team_count, mySize, 3);
2417                         columns = ceil(team_count/rows);
2418                         score_size = eX * mySize.x*(1/columns) + eY * mySize.y*(1/rows);
2419
2420                         float newSize;
2421                         if(score_size.x/score_size.y > 3)
2422                         {
2423                                 newSize = 3 * score_size.y;
2424                                 offset.x = score_size.x - newSize;
2425                                 pos.x += offset.x/2;
2426                                 score_size.x = newSize;
2427                         }
2428                         else
2429                         {
2430                                 newSize = 1/3 * score_size.x;
2431                                 offset.y = score_size.y - newSize;
2432                                 pos.y += offset.y/2;
2433                                 score_size.y = newSize;
2434                         }
2435                 }
2436                 else
2437                         score_size = eX * mySize.x*(1/4) + eY * mySize.y*(1/3);
2438
2439                 float max_fragcount;
2440                 max_fragcount = -99;
2441                 draw_beginBoldFont();
2442                 row = column = 0;
2443                 for(tm = teams.sort_next; tm; tm = tm.sort_next) {
2444                         if(tm.team == NUM_SPECTATOR)
2445                                 continue;
2446                         score = tm.(teamscores[ts_primary]);
2447                         if(autocvar__hud_configure)
2448                                 score = 123;
2449
2450                         if (score > max_fragcount)
2451                                 max_fragcount = score;
2452
2453                         if (spectatee_status == -1)
2454                         {
2455                                 score_pos = pos + eX * column * (score_size.x + offset.x) + eY * row * (score_size.y + offset.y);
2456                                 if (max_fragcount == score)
2457                                         HUD_Panel_DrawHighlight(score_pos, score_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2458                                 drawstring_aspect(score_pos, ftos(score), score_size, Team_ColorRGB(tm.team) * 0.8, panel_fg_alpha, DRAWFLAG_NORMAL);
2459                                 ++row;
2460                                 if(row >= rows)
2461                                 {
2462                                         row = 0;
2463                                         ++column;
2464                                 }
2465                         }
2466                         else if(tm.team == myteam) {
2467                                 if (max_fragcount == score)
2468                                         HUD_Panel_DrawHighlight(pos, eX * 0.75 * mySize.x + eY * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2469                                 drawstring_aspect(pos, ftos(score), eX * 0.75 * mySize.x + eY * mySize.y, Team_ColorRGB(tm.team) * 0.8, panel_fg_alpha, DRAWFLAG_NORMAL);
2470                         } else {
2471                                 if (max_fragcount == score)
2472                                         HUD_Panel_DrawHighlight(pos + eX * 0.75 * mySize.x + eY * (1/3) * rows * mySize.y, score_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2473                                 drawstring_aspect(pos + eX * 0.75 * mySize.x + eY * (1/3) * rows * mySize.y, ftos(score), score_size, Team_ColorRGB(tm.team) * 0.8, panel_fg_alpha, DRAWFLAG_NORMAL);
2474                                 ++rows;
2475                         }
2476                 }
2477                 draw_endBoldFont();
2478         }
2479 }
2480
2481 // Race timer (#8)
2482 //
2483 void HUD_RaceTimer (void)
2484 {
2485         if(!autocvar__hud_configure)
2486         {
2487                 if(!autocvar_hud_panel_racetimer) return;
2488                 if(!(gametype == MAPINFO_TYPE_RACE || gametype == MAPINFO_TYPE_CTS)) return;
2489                 if(spectatee_status == -1) return;
2490         }
2491
2492         HUD_Panel_UpdateCvars();
2493
2494         vector pos, mySize;
2495         pos = panel_pos;
2496         mySize = panel_size;
2497
2498         HUD_Panel_DrawBg(1);
2499         if(panel_bg_padding)
2500         {
2501                 pos += '1 1 0' * panel_bg_padding;
2502                 mySize -= '2 2 0' * panel_bg_padding;
2503         }
2504
2505         // always force 4:1 aspect
2506         vector newSize = '0 0 0';
2507         if(mySize.x/mySize.y > 4)
2508         {
2509                 newSize.x = 4 * mySize.y;
2510                 newSize.y = mySize.y;
2511
2512                 pos.x = pos.x + (mySize.x - newSize.x) / 2;
2513         }
2514         else
2515         {
2516                 newSize.y = 1/4 * mySize.x;
2517                 newSize.x = mySize.x;
2518
2519                 pos.y = pos.y + (mySize.y - newSize.y) / 2;
2520         }
2521         mySize = newSize;
2522
2523         float a, t;
2524         string s, forcetime;
2525
2526         if(autocvar__hud_configure)
2527         {
2528                 s = "0:13:37";
2529                 draw_beginBoldFont();
2530                 drawstring(pos + eX * 0.5 * mySize.x - '0.5 0 0' * stringwidth(s, false, '0.60 0.60 0' * mySize.y), s, '0.60 0.60 0' * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2531                 draw_endBoldFont();
2532                 s = _("^1Intermediate 1 (+15.42)");
2533                 drawcolorcodedstring(pos + eX * 0.5 * mySize.x - '0.5 0 0' * stringwidth(s, true, '1 1 0' * 0.20 * mySize.y) + eY * 0.60 * mySize.y, s, '1 1 0' * 0.20 * mySize.y, panel_fg_alpha, DRAWFLAG_NORMAL);
2534                 s = sprintf(_("^1PENALTY: %.1f (%s)"), 2, "missing a checkpoint");
2535                 drawcolorcodedstring(pos + eX * 0.5 * mySize.x - '0.5 0 0' * stringwidth(s, true, '1 1 0' * 0.20 * mySize.y) + eY * 0.80 * mySize.y, s, '1 1 0' * 0.20 * mySize.y, panel_fg_alpha, DRAWFLAG_NORMAL);
2536         }
2537         else if(race_checkpointtime)
2538         {
2539                 a = bound(0, 2 - (time - race_checkpointtime), 1);
2540                 s = "";
2541                 forcetime = "";
2542                 if(a > 0) // just hit a checkpoint?
2543                 {
2544                         if(race_checkpoint != 254)
2545                         {
2546                                 if(race_time && race_previousbesttime)
2547                                         s = MakeRaceString(race_checkpoint, TIME_DECODE(race_time) - TIME_DECODE(race_previousbesttime), 0, 0, race_previousbestname);
2548                                 else
2549                                         s = MakeRaceString(race_checkpoint, 0, -1, 0, race_previousbestname);
2550                                 if(race_time)
2551                                         forcetime = TIME_ENCODED_TOSTRING(race_time);
2552                         }
2553                 }
2554                 else
2555                 {
2556                         if(race_laptime && race_nextbesttime && race_nextcheckpoint != 254)
2557                         {
2558                                 a = bound(0, 2 - ((race_laptime + TIME_DECODE(race_nextbesttime)) - (time + TIME_DECODE(race_penaltyaccumulator))), 1);
2559                                 if(a > 0) // next one?
2560                                 {
2561                                         s = MakeRaceString(race_nextcheckpoint, (time + TIME_DECODE(race_penaltyaccumulator)) - race_laptime, TIME_DECODE(race_nextbesttime), 0, race_nextbestname);
2562                                 }
2563                         }
2564                 }
2565
2566                 if(s != "" && a > 0)
2567                 {
2568                         drawcolorcodedstring(pos + eX * 0.5 * mySize.x - '0.5 0 0' * stringwidth(s, true, '1 1 0' * 0.2 * mySize.y) + eY * 0.6 * mySize.y, s, '1 1 0' * 0.2 * mySize.y, panel_fg_alpha * a, DRAWFLAG_NORMAL);
2569                 }
2570
2571                 if(race_penaltytime)
2572                 {
2573                         a = bound(0, 2 - (time - race_penaltyeventtime), 1);
2574                         if(a > 0)
2575                         {
2576                                 s = sprintf(_("^1PENALTY: %.1f (%s)"), race_penaltytime * 0.1, race_penaltyreason);
2577                                 drawcolorcodedstring(pos + eX * 0.5 * mySize.x - '0.5 0 0' * stringwidth(s, true, '1 1 0' * 0.2 * mySize.y) + eY * 0.8 * mySize.y, s, '1 1 0' * 0.2 * mySize.y, panel_fg_alpha * a, DRAWFLAG_NORMAL);
2578                         }
2579                 }
2580
2581                 draw_beginBoldFont();
2582
2583                 if(forcetime != "")
2584                 {
2585                         a = bound(0, (time - race_checkpointtime) / 0.5, 1);
2586                         drawstring_expanding(pos + eX * 0.5 * mySize.x - '0.5 0 0' * stringwidth(forcetime, false, '1 1 0' * 0.6 * mySize.y), forcetime, '1 1 0' * 0.6 * mySize.y, '1 1 1', panel_fg_alpha, 0, a);
2587                 }
2588                 else
2589                         a = 1;
2590
2591                 if(race_laptime && race_checkpoint != 255)
2592                 {
2593                         s = TIME_ENCODED_TOSTRING(TIME_ENCODE(time + TIME_DECODE(race_penaltyaccumulator) - race_laptime));
2594                         drawstring(pos + eX * 0.5 * mySize.x - '0.5 0 0' * stringwidth(s, false, '0.6 0.6 0' * mySize.y), s, '0.6 0.6 0' * mySize.y, '1 1 1', panel_fg_alpha * a, DRAWFLAG_NORMAL);
2595                 }
2596
2597                 draw_endBoldFont();
2598         }
2599         else
2600         {
2601                 if(race_mycheckpointtime)
2602                 {
2603                         a = bound(0, 2 - (time - race_mycheckpointtime), 1);
2604                         s = MakeRaceString(race_mycheckpoint, TIME_DECODE(race_mycheckpointdelta), -(race_mycheckpointenemy == ""), race_mycheckpointlapsdelta, race_mycheckpointenemy);
2605                         drawcolorcodedstring(pos + eX * 0.5 * mySize.x - '0.5 0 0' * stringwidth(s, true, '1 1 0' * 0.2 * mySize.y) + eY * 0.6 * mySize.y, s, '1 1 0' * 0.2 * mySize.y, panel_fg_alpha * a, DRAWFLAG_NORMAL);
2606                 }
2607                 if(race_othercheckpointtime && race_othercheckpointenemy != "")
2608                 {
2609                         a = bound(0, 2 - (time - race_othercheckpointtime), 1);
2610                         s = MakeRaceString(race_othercheckpoint, -TIME_DECODE(race_othercheckpointdelta), -(race_othercheckpointenemy == ""), race_othercheckpointlapsdelta, race_othercheckpointenemy);
2611                         drawcolorcodedstring(pos + eX * 0.5 * mySize.x - '0.5 0 0' * stringwidth(s, true, '1 1 0' * 0.2 * mySize.y) + eY * 0.6 * mySize.y, s, '1 1 0' * 0.2 * mySize.y, panel_fg_alpha * a, DRAWFLAG_NORMAL);
2612                 }
2613
2614                 if(race_penaltytime && !race_penaltyaccumulator)
2615                 {
2616                         t = race_penaltytime * 0.1 + race_penaltyeventtime;
2617                         a = bound(0, (1 + t - time), 1);
2618                         if(a > 0)
2619                         {
2620                                 if(time < t)
2621                                         s = sprintf(_("^1PENALTY: %.1f (%s)"), (t - time) * 0.1, race_penaltyreason);
2622                                 else
2623                                         s = sprintf(_("^2PENALTY: %.1f (%s)"), 0, race_penaltyreason);
2624                                 drawcolorcodedstring(pos + eX * 0.5 * mySize.x - '0.5 0 0' * stringwidth(s, true, '1 1 0' * 0.2 * mySize.y) + eY * 0.6 * mySize.y, s, '1 1 0' * 0.2 * mySize.y, panel_fg_alpha * a, DRAWFLAG_NORMAL);
2625                         }
2626                 }
2627         }
2628 }
2629
2630 // Vote window (#9)
2631 //
2632
2633 void HUD_Vote(void)
2634 {
2635         if(autocvar_cl_allow_uid2name == -1 && (gametype == MAPINFO_TYPE_CTS || gametype == MAPINFO_TYPE_RACE || (serverflags & SERVERFLAG_PLAYERSTATS)))
2636         {
2637                 vote_active = 1;
2638                 if (autocvar__hud_configure)
2639                 {
2640                         vote_yescount = 0;
2641                         vote_nocount = 0;
2642                         print(_("^1You must answer before entering hud configure mode\n"));
2643                         cvar_set("_hud_configure", "0");
2644                 }
2645                 if(vote_called_vote)
2646                         strunzone(vote_called_vote);
2647                 vote_called_vote = strzone(_("^2Name ^7instead of \"^1Anonymous player^7\" in stats"));
2648                 uid2name_dialog = 1;
2649         }
2650
2651         if(!autocvar__hud_configure)
2652         {
2653                 if(!autocvar_hud_panel_vote) return;
2654
2655                 panel_fg_alpha = autocvar_hud_panel_fg_alpha;
2656                 panel_bg_alpha_str = autocvar_hud_panel_vote_bg_alpha;
2657
2658                 if(panel_bg_alpha_str == "") {
2659                         panel_bg_alpha_str = ftos(autocvar_hud_panel_bg_alpha);
2660                 }
2661                 panel_bg_alpha = stof(panel_bg_alpha_str);
2662         }
2663         else
2664         {
2665                 vote_yescount = 3;
2666                 vote_nocount = 2;
2667                 vote_needed = 4;
2668         }
2669
2670         string s;
2671         float a;
2672         if(vote_active != vote_prev) {
2673                 vote_change = time;
2674                 vote_prev = vote_active;
2675         }
2676
2677         if(vote_active || autocvar__hud_configure)
2678                 vote_alpha = bound(0, (time - vote_change) * 2, 1);
2679         else
2680                 vote_alpha = bound(0, 1 - (time - vote_change) * 2, 1);
2681
2682         if(!vote_alpha)
2683                 return;
2684
2685         HUD_Panel_UpdateCvars();
2686
2687         if(uid2name_dialog)
2688         {
2689                 panel_pos = eX * 0.3 * vid_conwidth + eY * 0.1 * vid_conheight;
2690                 panel_size = eX * 0.4 * vid_conwidth + eY * 0.3 * vid_conheight;
2691         }
2692
2693     // these must be below above block
2694         vector pos, mySize;
2695         pos = panel_pos;
2696         mySize = panel_size;
2697
2698         a = vote_alpha * (vote_highlighted ? autocvar_hud_panel_vote_alreadyvoted_alpha : 1);
2699         HUD_Panel_DrawBg(a);
2700         a = panel_fg_alpha * a;
2701
2702         if(panel_bg_padding)
2703         {
2704                 pos += '1 1 0' * panel_bg_padding;
2705                 mySize -= '2 2 0' * panel_bg_padding;
2706         }
2707
2708         // always force 3:1 aspect
2709         vector newSize = '0 0 0';
2710         if(mySize.x/mySize.y > 3)
2711         {
2712                 newSize.x = 3 * mySize.y;
2713                 newSize.y = mySize.y;
2714
2715                 pos.x = pos.x + (mySize.x - newSize.x) / 2;
2716         }
2717         else
2718         {
2719                 newSize.y = 1/3 * mySize.x;
2720                 newSize.x = mySize.x;
2721
2722                 pos.y = pos.y + (mySize.y - newSize.y) / 2;
2723         }
2724         mySize = newSize;
2725
2726         s = _("A vote has been called for:");
2727         if(uid2name_dialog)
2728                 s = _("Allow servers to store and display your name?");
2729         drawstring_aspect(pos, s, eX * mySize.x + eY * (2/8) * mySize.y, '1 1 1', a, DRAWFLAG_NORMAL);
2730         s = textShortenToWidth(vote_called_vote, mySize.x, '1 1 0' * mySize.y * (1/8), stringwidth_colors);
2731         if(autocvar__hud_configure)
2732                 s = _("^1Configure the HUD");
2733         drawcolorcodedstring_aspect(pos + eY * (2/8) * mySize.y, s, eX * mySize.x + eY * (1.75/8) * mySize.y, a, DRAWFLAG_NORMAL);
2734
2735         // print the yes/no counts
2736     s = sprintf(_("Yes (%s): %d"), getcommandkey("vyes", "vyes"), vote_yescount);
2737         drawstring_aspect(pos + eY * (4/8) * mySize.y, s, eX * 0.5 * mySize.x + eY * (1.5/8) * mySize.y, '0 1 0', a, DRAWFLAG_NORMAL);
2738     s = sprintf(_("No (%s): %d"), getcommandkey("vno", "vno"), vote_nocount);
2739         drawstring_aspect(pos + eX * 0.5 * mySize.x + eY * (4/8) * mySize.y, s, eX * 0.5 * mySize.x + eY * (1.5/8) * mySize.y, '1 0 0', a, DRAWFLAG_NORMAL);
2740
2741         // draw the progress bar backgrounds
2742         drawpic_skin(pos + eY * (5/8) * mySize.y, "voteprogress_back", eX * mySize.x + eY * (3/8) * mySize.y, '1 1 1', a, DRAWFLAG_NORMAL);
2743
2744         // draw the highlights
2745         if(vote_highlighted == 1) {
2746                 drawsetcliparea(pos.x, pos.y, mySize.x * 0.5, mySize.y);
2747                 drawpic_skin(pos + eY * (5/8) * mySize.y, "voteprogress_voted", eX * mySize.x + eY * (3/8) * mySize.y, '1 1 1', a, DRAWFLAG_NORMAL);
2748         }
2749         else if(vote_highlighted == -1) {
2750                 drawsetcliparea(pos.x + 0.5 * mySize.x, pos.y, mySize.x * 0.5, mySize.y);
2751                 drawpic_skin(pos + eY * (5/8) * mySize.y, "voteprogress_voted", eX * mySize.x + eY * (3/8) * mySize.y, '1 1 1', a, DRAWFLAG_NORMAL);
2752         }
2753
2754         // draw the progress bars
2755         if(vote_yescount && vote_needed)
2756         {
2757                 drawsetcliparea(pos.x, pos.y, mySize.x * 0.5 * (vote_yescount/vote_needed), mySize.y);
2758                 drawpic_skin(pos + eY * (5/8) * mySize.y, "voteprogress_prog", eX * mySize.x + eY * (3/8) * mySize.y, '1 1 1', a, DRAWFLAG_NORMAL);
2759         }
2760
2761         if(vote_nocount && vote_needed)
2762         {
2763                 drawsetcliparea(pos.x + mySize.x - mySize.x * 0.5 * (vote_nocount/vote_needed), pos.y, mySize.x * 0.5, mySize.y);
2764                 drawpic_skin(pos + eY * (5/8) * mySize.y, "voteprogress_prog", eX * mySize.x + eY * (3/8) * mySize.y, '1 1 1', a, DRAWFLAG_NORMAL);
2765         }
2766
2767         drawresetcliparea();
2768 }
2769
2770 // Mod icons panel (#10)
2771 //
2772
2773 bool mod_active; // is there any active mod icon?
2774
2775 void DrawCAItem(vector myPos, vector mySize, float aspect_ratio, int layout, int i)
2776 {
2777         int stat = -1;
2778         string pic = "";
2779         vector color = '0 0 0';
2780         switch(i)
2781         {
2782                 case 0:
2783                         stat = getstati(STAT_REDALIVE);
2784                         pic = "player_red.tga";
2785                         color = '1 0 0';
2786                         break;
2787                 case 1:
2788                         stat = getstati(STAT_BLUEALIVE);
2789                         pic = "player_blue.tga";
2790                         color = '0 0 1';
2791                         break;
2792                 case 2:
2793                         stat = getstati(STAT_YELLOWALIVE);
2794                         pic = "player_yellow.tga";
2795                         color = '1 1 0';
2796                         break;
2797                 default:
2798                 case 3:
2799                         stat = getstati(STAT_PINKALIVE);
2800                         pic = "player_pink.tga";
2801                         color = '1 0 1';
2802                         break;
2803         }
2804
2805         if(mySize.x/mySize.y > aspect_ratio)
2806         {
2807                 i = aspect_ratio * mySize.y;
2808                 myPos.x = myPos.x + (mySize.x - i) / 2;
2809                 mySize.x = i;
2810         }
2811         else
2812         {
2813                 i = 1/aspect_ratio * mySize.x;
2814                 myPos.y = myPos.y + (mySize.y - i) / 2;
2815                 mySize.y = i;
2816         }
2817
2818         if(layout)
2819         {
2820                 drawpic_aspect_skin(myPos, pic, eX * 0.7 * mySize.x + eY * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2821                 drawstring_aspect(myPos + eX * 0.7 * mySize.x, ftos(stat), eX * 0.3 * mySize.x + eY * mySize.y, color, panel_fg_alpha, DRAWFLAG_NORMAL);
2822         }
2823         else
2824                 drawstring_aspect(myPos, ftos(stat), mySize, color, panel_fg_alpha, DRAWFLAG_NORMAL);
2825 }
2826
2827 // Clan Arena and Freeze Tag HUD modicons
2828 void HUD_Mod_CA(vector myPos, vector mySize)
2829 {
2830         mod_active = 1; // required in each mod function that always shows something
2831
2832         int layout;
2833         if(gametype == MAPINFO_TYPE_CA)
2834                 layout = autocvar_hud_panel_modicons_ca_layout;
2835         else //if(gametype == MAPINFO_TYPE_FREEZETAG)
2836                 layout = autocvar_hud_panel_modicons_freezetag_layout;
2837         int rows, columns;
2838         float aspect_ratio;
2839         aspect_ratio = (layout) ? 2 : 1;
2840         rows = HUD_GetRowCount(team_count, mySize, aspect_ratio);
2841         columns = ceil(team_count/rows);
2842
2843         int i;
2844         float row = 0, column = 0;
2845         vector pos, itemSize;
2846         itemSize = eX * mySize.x*(1/columns) + eY * mySize.y*(1/rows);
2847         for(i=0; i<team_count; ++i)
2848         {
2849                 pos = myPos + eX * column * itemSize.x + eY * row * itemSize.y;
2850
2851                 DrawCAItem(pos, itemSize, aspect_ratio, layout, i);
2852
2853                 ++row;
2854                 if(row >= rows)
2855                 {
2856                         row = 0;
2857                         ++column;
2858                 }
2859         }
2860 }
2861
2862 // CTF HUD modicon section
2863 float redflag_prevframe, blueflag_prevframe; // status during previous frame
2864 int redflag_prevstatus, blueflag_prevstatus; // last remembered status
2865 float redflag_statuschange_time, blueflag_statuschange_time; // time when the status changed
2866
2867 void HUD_Mod_CTF_Reset(void)
2868 {
2869         redflag_prevstatus = blueflag_prevstatus = redflag_prevframe = blueflag_prevframe = redflag_statuschange_time = blueflag_statuschange_time = 0;
2870 }
2871
2872 void HUD_Mod_CTF(vector pos, vector mySize)
2873 {
2874         vector redflag_pos, blueflag_pos;
2875         vector flag_size;
2876         float f; // every function should have that
2877