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