Merge remote branch 'origin/fruitiex/newpanelhud'
[xonotic/xonotic-data.pk3dir.git] / qcsrc / client / hud.qc
1 /*
2 ==================
3 Misc HUD functions
4 ==================
5 */
6
7 // a border picture is a texture containing nine parts:
8 //   1/4 width: left part
9 //   1/2 width: middle part (stretched)
10 //   1/4 width: right part
11 // divided into
12 //   1/4 height: top part
13 //   1/2 height: middle part (stretched)
14 //   1/4 height: bottom part
15 void draw_BorderPicture(vector theOrigin, string pic, vector theSize, vector theColor, float theAlpha, vector theBorderSize)
16 {
17         if (theBorderSize_x <= 0 && theBorderSize_y <= 0) // no border
18         {
19                 // draw only the central part
20                 drawsubpic(theOrigin, theSize, pic, '0.25 0.25 0', '0.5 0.5 0', theColor, theAlpha, 0);
21                 return;
22         }
23
24         vector dX, dY;
25         vector width, height;
26         vector bW, bH;
27         //pic = draw_UseSkinFor(pic);
28         width = eX * theSize_x;
29         height = eY * theSize_y;
30         if(theSize_x <= theBorderSize_x * 2)
31         {
32                 // not wide enough... draw just left and right then
33                 bW = eX * (0.25 * theSize_x / (theBorderSize_x * 2));
34                 if(theSize_y <= theBorderSize_y * 2)
35                 {
36                         // not high enough... draw just corners
37                         bH = eY * (0.25 * theSize_y / (theBorderSize_y * 2));
38                         drawsubpic(theOrigin,                 width * 0.5 + height * 0.5, pic, '0 0 0',           bW + bH, theColor, theAlpha, 0);
39                         drawsubpic(theOrigin + width   * 0.5, width * 0.5 + height * 0.5, pic, eX - bW,           bW + bH, theColor, theAlpha, 0);
40                         drawsubpic(theOrigin + height  * 0.5, width * 0.5 + height * 0.5, pic, eY - bH,           bW + bH, theColor, theAlpha, 0);
41                         drawsubpic(theOrigin + theSize * 0.5, width * 0.5 + height * 0.5, pic, eX + eY - bW - bH, bW + bH, theColor, theAlpha, 0);
42                 }
43                 else
44                 {
45                         dY = theBorderSize_x * eY;
46                         drawsubpic(theOrigin,                             width * 0.5          +     dY, pic, '0 0    0',           '0 0.25 0' + bW, theColor, theAlpha, 0);
47                         drawsubpic(theOrigin + width * 0.5,               width * 0.5          +     dY, pic, '0 0    0' + eX - bW, '0 0.25 0' + bW, theColor, theAlpha, 0);
48                         drawsubpic(theOrigin                        + dY, width * 0.5 + height - 2 * dY, pic, '0 0.25 0',           '0 0.5  0' + bW, theColor, theAlpha, 0);
49                         drawsubpic(theOrigin + width * 0.5          + dY, width * 0.5 + height - 2 * dY, pic, '0 0.25 0' + eX - bW, '0 0.5  0' + bW, theColor, theAlpha, 0);
50                         drawsubpic(theOrigin               + height - dY, width * 0.5          +     dY, pic, '0 0.75 0',           '0 0.25 0' + bW, theColor, theAlpha, 0);
51                         drawsubpic(theOrigin + width * 0.5 + height - dY, width * 0.5          +     dY, pic, '0 0.75 0' + eX - bW, '0 0.25 0' + bW, theColor, theAlpha, 0);
52                 }
53         }
54         else
55         {
56                 if(theSize_y <= theBorderSize_y * 2)
57                 {
58                         // not high enough... draw just top and bottom then
59                         bH = eY * (0.25 * theSize_y / (theBorderSize_y * 2));
60                         dX = theBorderSize_x * eX;
61                         drawsubpic(theOrigin,                                         dX + height * 0.5, pic, '0    0 0',           '0.25 0 0' + bH, theColor, theAlpha, 0);
62                         drawsubpic(theOrigin + dX,                        width - 2 * dX + height * 0.5, pic, '0.25 0 0',           '0.5  0 0' + bH, theColor, theAlpha, 0);
63                         drawsubpic(theOrigin + width - dX,                            dX + height * 0.5, pic, '0.75 0 0',           '0.25 0 0' + bH, theColor, theAlpha, 0);
64                         drawsubpic(theOrigin              + height * 0.5,             dX + height * 0.5, pic, '0    0 0' + eY - bH, '0.25 0 0' + bH, theColor, theAlpha, 0);
65                         drawsubpic(theOrigin + dX         + height * 0.5, width - 2 * dX + height * 0.5, pic, '0.25 0 0' + eY - bH, '0.5  0 0' + bH, theColor, theAlpha, 0);
66                         drawsubpic(theOrigin + width - dX + height * 0.5,             dX + height * 0.5, pic, '0.75 0 0' + eY - bH, '0.25 0 0' + bH, theColor, theAlpha, 0);
67                 }
68                 else
69                 {
70                         dX = theBorderSize_x * eX;
71                         dY = theBorderSize_x * eY;
72                         drawsubpic(theOrigin,                                        dX          +     dY, pic, '0    0    0', '0.25 0.25 0', theColor, theAlpha, 0);
73                         drawsubpic(theOrigin                  + dX,      width - 2 * dX          +     dY, pic, '0.25 0    0', '0.5  0.25 0', theColor, theAlpha, 0);
74                         drawsubpic(theOrigin          + width - dX,                  dX          +     dY, pic, '0.75 0    0', '0.25 0.25 0', theColor, theAlpha, 0);
75                         drawsubpic(theOrigin          + dY,                          dX + height - 2 * dY, pic, '0    0.25 0', '0.25 0.5  0', theColor, theAlpha, 0);
76                         drawsubpic(theOrigin          + dY         + dX, width - 2 * dX + height - 2 * dY, pic, '0.25 0.25 0', '0.5  0.5  0', theColor, theAlpha, 0);
77                         drawsubpic(theOrigin          + dY + width - dX,             dX + height - 2 * dY, pic, '0.75 0.25 0', '0.25 0.5  0', theColor, theAlpha, 0);
78                         drawsubpic(theOrigin + height - dY,                          dX          +     dY, pic, '0    0.75 0', '0.25 0.25 0', theColor, theAlpha, 0);
79                         drawsubpic(theOrigin + height - dY         + dX, width - 2 * dX          +     dY, pic, '0.25 0.75 0', '0.5  0.25 0', theColor, theAlpha, 0);
80                         drawsubpic(theOrigin + height - dY + width - dX,             dX          +     dY, pic, '0.75 0.75 0', '0.25 0.25 0', theColor, theAlpha, 0);
81                 }
82         }
83 }
84
85 vector HUD_Get_Num_Color (float x, float maxvalue)
86 {
87         vector color;
88         if(x > maxvalue) {
89                 color_x = 0;
90                 color_y = 1;
91                 color_z = 0;
92         }
93         else if(x > maxvalue * 0.75) {
94                 color_x = 0.4 - (x-150)*0.02 * 0.4; //red value between 0.4 -> 0
95                 color_y = 0.9 + (x-150)*0.02 * 0.1; // green value between 0.9 -> 1
96                 color_z = 0;
97         }
98         else if(x > maxvalue * 0.5) {
99                 color_x = 1 - (x-100)*0.02 * 0.6; //red value between 1 -> 0.4
100                 color_y = 1 - (x-100)*0.02 * 0.1; // green value between 1 -> 0.9
101                 color_z = 1 - (x-100)*0.02; // blue value between 1 -> 0
102         }
103         else if(x > maxvalue * 0.25) {
104                 color_x = 1;
105                 color_y = 1;
106                 color_z = 0.2 + (x-50)*0.02 * 0.8; // blue value between 0.2 -> 1
107         }
108         else if(x > maxvalue * 0.1) {
109                 color_x = 1;
110                 color_y = (x-20)*90/27/100; // green value between 0 -> 1
111                 color_z = (x-20)*90/27/100 * 0.2; // blue value between 0 -> 0.2
112         }
113         else {
114                 color_x = 1;
115                 color_y = 0;
116                 color_z = 0;
117         }
118         return color;
119 }
120
121 float stringwidth_colors(string s, vector theSize)
122 {
123         return stringwidth(s, TRUE, theSize);
124 }
125
126 float stringwidth_nocolors(string s, vector theSize)
127 {
128         return stringwidth(s, FALSE, theSize);
129 }
130
131 #define CENTERPRINT_MAX_LINES 30
132 string centerprint_messages[CENTERPRINT_MAX_LINES];
133 float centerprint_width[CENTERPRINT_MAX_LINES];
134 float centerprint_time;
135 float centerprint_expire;
136 float centerprint_num;
137 float centerprint_offset_hint;
138 vector centerprint_fontsize;
139
140 void centerprint(string strMessage)
141 {
142         float i, j, n, hcount;
143         string s;
144
145         centerprint_fontsize = HUD_GetFontsize("scr_centersize");
146
147         centerprint_expire = min(centerprint_expire, time); // if any of the returns happens, this message will fade out
148
149         if(cvar("scr_centertime") <= 0)
150                 return;
151
152         if(strMessage == "")
153                 return;
154
155         // strip trailing newlines
156         j = strlen(strMessage) - 1;
157         while(substring(strMessage, j, 1) == "\n" && j >= 0)
158                 j = j - 1;
159         strMessage = substring(strMessage, 0, j + 1);
160
161         if(strMessage == "")
162                 return;
163
164         // strip leading newlines and remember them, they are a hint that the message should be lower on the screen
165         j = 0;
166         while(substring(strMessage, j, 1) == "\n" && j < strlen(strMessage))
167                 j = j + 1;
168         strMessage = substring(strMessage, j, strlen(strMessage) - j);
169         centerprint_offset_hint = j;
170
171         if(strMessage == "")
172                 return;
173
174         // if we get here, we have a message. Initialize its height.
175         centerprint_num = 0;
176
177         n = tokenizebyseparator(strMessage, "\n");
178         i = hcount = 0;
179         for(j = 0; j < n; ++j)
180         {
181                 getWrappedLine_remaining = argv(j);
182                 while(getWrappedLine_remaining)
183                 {
184                         s = getWrappedLine(vid_conwidth * 0.75, centerprint_fontsize, stringwidth_colors);
185                         if(centerprint_messages[i] != s) // don't fade the same message in, looks stupid
186                                 centerprint_time = time;
187                         if(centerprint_messages[i])
188                                 strunzone(centerprint_messages[i]);
189                         centerprint_messages[i] = strzone(s);
190                         centerprint_width[i] = stringwidth(s, TRUE, centerprint_fontsize);
191                         ++i;
192
193                         // half height for empty lines looks better
194                         if(s == "")
195                                 hcount += 0.5;
196                         else
197                                 hcount += 1;
198
199                         if(i >= CENTERPRINT_MAX_LINES)
200                                 break;
201                 }
202         }
203
204         float h, havail;
205         h = centerprint_fontsize_y*hcount;
206
207         havail = vid_conheight;
208         if(cvar("con_chatpos") < 0)
209                 havail -= (-cvar("con_chatpos") + cvar("con_chat")) * cvar("con_chatsize"); // avoid overlapping chat
210         if(havail > vid_conheight - 70)
211                 havail = vid_conheight - 70; // avoid overlapping HUD
212
213 #if 0
214         float forbiddenmin, forbiddenmax, allowedmin, allowedmax, preferred;
215
216         // here, the centerprint would cover the crosshair. REALLY BAD.
217         forbiddenmin = vid_conheight * 0.5 - h - 16;
218         forbiddenmax = vid_conheight * 0.5 + 16;
219
220         allowedmin = scoreboard_bottom;
221         allowedmax = havail - h;
222         preferred = (havail - h)/2;
223
224
225         // possible orderings (total: 4! / 4 = 6)
226         //  allowedmin allowedmax forbiddenmin forbiddenmax
227         //  forbiddenmin forbiddenmax allowedmin allowedmax
228         if(allowedmax < forbiddenmin || allowedmin > forbiddenmax)
229         {
230                 // forbidden doesn't matter in this case
231                 centerprint_start_y = bound(allowedmin, preferred, allowedmax);
232         }
233         //  allowedmin forbiddenmin allowedmax forbiddenmax
234         else if(allowedmin < forbiddenmin && allowedmax < forbiddenmax)
235         {
236                 centerprint_start_y = bound(allowedmin, preferred, forbiddenmin);
237         }
238         //  allowedmin forbiddenmin forbiddenmax allowedmax
239         else if(allowedmin < forbiddenmin)
240         {
241                 // make sure the forbidden zone is not covered
242                 if(preferred > (forbiddenmin + forbiddenmax) * 0.5)
243                         centerprint_start_y = bound(allowedmin, preferred, forbiddenmin);
244                 else
245                         centerprint_start_y = bound(forbiddenmax, preferred, allowedmin);
246         }
247         //  forbiddenmin allowedmin allowedmax forbiddenmax
248         else if(allowedmax < forbiddenmax)
249         {
250                 // it's better to leave the allowed zone (overlap with scoreboard) than
251                 // to cover the forbidden zone (crosshair)
252                 if(preferred > (forbiddenmin + forbiddenmax) * 0.5)
253                         centerprint_start_y = forbiddenmax;
254                 else
255                         centerprint_start_y = forbiddenmin;
256         }
257         //  forbiddenmin allowedmin forbiddenmax allowedmax
258         else
259         {
260                 centerprint_start_y = bound(forbiddenmax, preferred, allowedmax);
261         }
262 #else
263 #endif
264
265         centerprint_num = i;
266
267         centerprint_expire = time + cvar("scr_centertime");
268 }
269
270 void HUD_DrawCenterPrint (void)
271 {
272         float i;
273         vector pos;
274         string ts;
275         float a, sz;
276
277         if(time - centerprint_time < 0.25)
278                 a = (time - centerprint_time) / 0.25;
279         else
280                 a = bound(0, 1 - 4 * (time - centerprint_expire), 1);
281
282         if(a <= 0)
283                 return;
284
285         sz = 0.8 + (a / 5);
286
287         if(centerprint_num * cvar("scr_centersize") > 24 && scoreboard_active) // 24 = height of Scoreboard text
288                 centerprint_start_y = scoreboard_bottom + centerprint_fontsize_y;
289
290         pos = centerprint_start;
291         for (i=0; i<centerprint_num; i = i + 1)
292         {
293                 ts = centerprint_messages[i];
294                 drawfontscale = sz * '1 1 0';
295                 drawfont = hud_bigfont;
296                 pos_x = (vid_conwidth - stringwidth(ts, TRUE, centerprint_fontsize)) * 0.5;
297                 if (ts != "")
298                 {
299                         drawcolorcodedstring(pos + '0 1 0' * (1 - sz) * 0.5 *centerprint_fontsize_y, ts, centerprint_fontsize, a, DRAWFLAG_NORMAL);
300                         pos_y = pos_y + centerprint_fontsize_y;
301                 }
302                 else
303                         // half height for empty lines looks better
304                         pos_y = pos_y + sz * centerprint_fontsize_y * 0.5;
305                 drawfontscale = '1 1 0';
306                 drawfont = hud_font;
307         }
308 }
309
310 void drawstringright(vector position, string text, vector scale, vector rgb, float alpha, float flag)
311 {
312         position_x -= 2 / 3 * strlen(text) * scale_x;
313         drawstring(position, text, scale, rgb, alpha, flag);
314 }
315
316 void drawstringcenter(vector position, string text, vector scale, vector rgb, float alpha, float flag)
317 {
318         position_x = 0.5 * (vid_conwidth - 0.6025 * strlen(text) * scale_x);
319         drawstring(position, text, scale, rgb, alpha, flag);
320 }
321
322 // return the string of the given race place
323 string race_PlaceName(float pos) {
324         if(pos == 1)
325                 return "1st";
326         else if(pos == 2)
327                 return "2nd";
328         else if(pos == 3)
329                 return "3rd";
330         else
331                 return strcat(ftos(pos), "th");
332 }
333
334 // return the string of the onscreen race timer
335 string MakeRaceString(float cp, float mytime, float histime, float lapdelta, string hisname)
336 {
337         string col;
338         string timestr;
339         string cpname;
340         string lapstr;
341         lapstr = "";
342
343         if(histime == 0) // goal hit
344         {
345                 if(mytime > 0)
346                 {
347                         timestr = strcat("+", ftos_decimals(+mytime, TIME_DECIMALS));
348                         col = "^1";
349                 }
350                 else if(mytime == 0)
351                 {
352                         timestr = "+0.0";
353                         col = "^3";
354                 }
355                 else
356                 {
357                         timestr = strcat("-", ftos_decimals(-mytime, TIME_DECIMALS));
358                         col = "^2";
359                 }
360
361                 if(lapdelta > 0)
362                 {
363                         lapstr = strcat(" (-", ftos(lapdelta), "L)");
364                         col = "^2";
365                 }
366                 else if(lapdelta < 0)
367                 {
368                         lapstr = strcat(" (+", ftos(-lapdelta), "L)");
369                         col = "^1";
370                 }
371         }
372         else if(histime > 0) // anticipation
373         {
374                 if(mytime >= histime)
375                         timestr = strcat("+", ftos_decimals(mytime - histime, TIME_DECIMALS));
376                 else
377                         timestr = TIME_ENCODED_TOSTRING(TIME_ENCODE(histime));
378                 col = "^3";
379         }
380         else
381                 col = "^7";
382
383         if(cp == 254)
384                 cpname = "Start line";
385         else if(cp == 255)
386                 cpname = "Finish line";
387         else if(cp)
388                 cpname = strcat("Intermediate ", ftos(cp));
389         else
390                 cpname = "Finish line";
391
392         if(histime < 0)
393                 return strcat(col, cpname);
394         else if(hisname == "")
395                 return strcat(col, cpname, " (", timestr, ")");
396         else
397                 return strcat(col, cpname, " (", timestr, " ", strcat(hisname, col, lapstr), ")");
398 }
399
400 // Check if the given name already exist in race rankings? In that case, where? (otherwise return 0)
401 float race_CheckName(string net_name) {
402         float i;
403         for (i=RANKINGS_CNT-1;i>=0;--i)
404                 if(grecordholder[i] == net_name)
405                         return i+1;
406         return 0;
407 }
408
409 /*
410 ==================
411 HUD panels
412 ==================
413 */
414
415 // Save the config
416 void HUD_Panel_ExportCfg(string cfgname)
417 {
418         float fh;
419         fh = fopen(strcat("hud_", autocvar_hud_skin, "_", cfgname, ".cfg"), FILE_WRITE);
420         if(fh >= 0)
421         {
422                 fputs(fh, strcat("seta hud_skin \"", cvar_string("hud_skin"), "\"", "\n"));
423                 fputs(fh, strcat("seta hud_panel_bg \"", cvar_string("hud_panel_bg"), "\"", "\n"));
424                 fputs(fh, strcat("seta hud_panel_bg_color \"", cvar_string("hud_panel_bg_color"), "\"", "\n"));
425                 fputs(fh, strcat("seta hud_panel_bg_color_team \"", cvar_string("hud_panel_bg_color_team"), "\"", "\n"));
426                 fputs(fh, strcat("seta hud_panel_bg_alpha \"", cvar_string("hud_panel_bg_alpha"), "\"", "\n"));
427                 fputs(fh, strcat("seta hud_panel_bg_border \"", cvar_string("hud_panel_bg_border"), "\"", "\n"));
428                 fputs(fh, strcat("seta hud_panel_bg_padding \"", cvar_string("hud_panel_bg_padding"), "\"", "\n"));
429                 fputs(fh, strcat("seta hud_panel_fg_alpha \"", cvar_string("hud_panel_fg_alpha"), "\"", "\n"));
430                 fputs(fh, "\n");
431
432                 fputs(fh, strcat("seta hud_dock \"", cvar_string("hud_dock"), "\"", "\n"));
433                 fputs(fh, strcat("seta hud_dock_color \"", cvar_string("hud_dock_color"), "\"", "\n"));
434                 fputs(fh, strcat("seta hud_dock_color_team \"", cvar_string("hud_dock_color_team"), "\"", "\n"));
435                 fputs(fh, strcat("seta hud_dock_alpha \"", cvar_string("hud_dock_alpha"), "\"", "\n"));
436                 fputs(fh, "\n");
437
438                 fputs(fh, strcat("seta hud_progressbar_alpha \"", cvar_string("hud_progressbar_alpha"), "\"", "\n"));
439                 fputs(fh, strcat("seta hud_progressbar_strength_color \"", cvar_string("hud_progressbar_strength_color"), "\"", "\n"));
440                 fputs(fh, strcat("seta hud_progressbar_shield_color \"", cvar_string("hud_progressbar_shield_color"), "\"", "\n"));
441                 fputs(fh, strcat("seta hud_progressbar_health_color \"", cvar_string("hud_progressbar_health_color"), "\"", "\n"));
442                 fputs(fh, strcat("seta hud_progressbar_armor_color \"", cvar_string("hud_progressbar_armor_color"), "\"", "\n"));
443                 fputs(fh, strcat("seta hud_progressbar_fuel_color \"", cvar_string("hud_progressbar_fuel_color"), "\"", "\n"));
444                 fputs(fh, strcat("seta hud_progressbar_nexball_color \"", cvar_string("hud_progressbar_nexball_color"), "\"", "\n"));
445                 fputs(fh, "\n");
446
447                 fputs(fh, strcat("seta _hud_panelorder \"", cvar_string("_hud_panelorder"), "\"", "\n"));
448                 fputs(fh, "\n");
449
450                 fputs(fh, strcat("seta hud_configure_grid \"", cvar_string("hud_configure_grid"), "\"", "\n"));
451                 fputs(fh, strcat("seta hud_configure_grid_xsize \"", cvar_string("hud_configure_grid_xsize"), "\"", "\n"));
452                 fputs(fh, strcat("seta hud_configure_grid_ysize \"", cvar_string("hud_configure_grid_ysize"), "\"", "\n"));
453                 fputs(fh, "\n");
454
455                 fputs(fh, strcat("seta scr_centerpos \"", cvar_string("scr_centerpos"), "\"", "\n"));
456                 fputs(fh, "\n");
457
458                 // common cvars for all panels
459                 float i;
460                 for (i = 0; i < HUD_PANEL_NUM; ++i)
461                 {
462                         HUD_Panel_GetName(i)
463
464                         fputs(fh, strcat("seta hud_panel_", panel_name, " ", cvar_string(strcat("hud_panel_", panel_name)), "\n"));
465                         fputs(fh, strcat("seta hud_panel_", panel_name, "_pos \"", cvar_string(strcat("hud_panel_", panel_name, "_pos")), "\"", "\n"));
466                         fputs(fh, strcat("seta hud_panel_", panel_name, "_size \"", cvar_string(strcat("hud_panel_", panel_name, "_size")), "\"", "\n"));
467                         fputs(fh, strcat("seta hud_panel_", panel_name, "_bg \"", cvar_string(strcat("hud_panel_", panel_name, "_bg")), "\"", "\n"));
468                         fputs(fh, strcat("seta hud_panel_", panel_name, "_bg_color \"", cvar_string(strcat("hud_panel_", panel_name, "_bg_color")), "\"", "\n"));
469                         fputs(fh, strcat("seta hud_panel_", panel_name, "_bg_color_team \"", cvar_string(strcat("hud_panel_", panel_name, "_bg_color_team")), "\"", "\n"));
470                         fputs(fh, strcat("seta hud_panel_", panel_name, "_bg_alpha \"", cvar_string(strcat("hud_panel_", panel_name, "_bg_alpha")), "\"", "\n"));
471                         fputs(fh, strcat("seta hud_panel_", panel_name, "_bg_border \"", cvar_string(strcat("hud_panel_", panel_name, "_bg_border")), "\"", "\n"));
472                         fputs(fh, strcat("seta hud_panel_", panel_name, "_bg_padding \"", cvar_string(strcat("hud_panel_", panel_name, "_bg_padding")), "\"", "\n"));
473                         switch(i) {
474                                 case HUD_PANEL_WEAPONS:
475                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_complainbubble \"", cvar_string(strcat("hud_panel_", panel_name, "_complainbubble")), "\"", "\n"));
476                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_complainbubble_padding \"", cvar_string(strcat("hud_panel_", panel_name, "_complainbubble_padding")), "\"", "\n"));
477                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_complainbubble_color_outofammo \"", cvar_string(strcat("hud_panel_", panel_name, "_complainbubble_color_outofammo")), "\"", "\n"));
478                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_complainbubble_color_donthave \"", cvar_string(strcat("hud_panel_", panel_name, "_complainbubble_color_donthave")), "\"", "\n"));
479                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_complainbubble_color_unavailable \"", cvar_string(strcat("hud_panel_", panel_name, "_complainbubble_color_unavailable")), "\"", "\n"));
480                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_ammo_color \"", cvar_string(strcat("hud_panel_", panel_name, "_ammo_color")), "\"", "\n"));
481                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_ammo_alpha \"", cvar_string(strcat("hud_panel_", panel_name, "_ammo_alpha")), "\"", "\n"));
482                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_aspect \"", cvar_string(strcat("hud_panel_", panel_name, "_aspect")), "\"", "\n"));
483                                         break;
484                                 case HUD_PANEL_AMMO:
485                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_onlycurrent \"", cvar_string(strcat("hud_panel_", panel_name, "_onlycurrent")), "\"", "\n"));
486                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_iconalign \"", cvar_string(strcat("hud_panel_", panel_name, "_iconalign")), "\"", "\n"));
487                                         break;
488                                 case HUD_PANEL_POWERUPS:
489                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_flip \"", cvar_string(strcat("hud_panel_", panel_name, "_flip")), "\"", "\n"));
490                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_iconalign \"", cvar_string(strcat("hud_panel_", panel_name, "_iconalign")), "\"", "\n"));
491                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_baralign \"", cvar_string(strcat("hud_panel_", panel_name, "_baralign")), "\"", "\n"));
492                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_progressbar \"", cvar_string(strcat("hud_panel_", panel_name, "_progressbar")), "\"", "\n"));
493                                         break;
494                                 case HUD_PANEL_HEALTHARMOR:
495                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_flip \"", cvar_string(strcat("hud_panel_", panel_name, "_flip")), "\n"));
496                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_iconalign \"", cvar_string(strcat("hud_panel_", panel_name, "_iconalign")), "\"", "\n"));
497                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_baralign \"", cvar_string(strcat("hud_panel_", panel_name, "_baralign")), "\"", "\n"));
498                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_progressbar \"", cvar_string(strcat("hud_panel_", panel_name, "_progressbar")), "\"", "\n"));
499                                         break;
500                                 case HUD_PANEL_NOTIFY:
501                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_flip \"", cvar_string(strcat("hud_panel_", panel_name, "_flip")), "\"", "\n"));
502                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_print \"", cvar_string(strcat("hud_panel_", panel_name, "_print")), "\"", "\n"));
503                                         break;
504                                 case HUD_PANEL_RADAR:
505                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_foreground_alpha \"", cvar_string(strcat("hud_panel_", panel_name, "_foreground_alpha")), "\"", "\n"));
506                                         break;
507                                 case HUD_PANEL_VOTE:
508                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_alreadyvoted_alpha \"", cvar_string(strcat("hud_panel_", panel_name, "_alreadyvoted_alpha")), "\"", "\n"));
509                                         break;
510                                 case HUD_PANEL_PRESSEDKEYS:
511                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_aspect \"", cvar_string(strcat("hud_panel_", panel_name, "_aspect")), "\"", "\n"));
512                                         break;
513                                 case HUD_PANEL_INFOMESSAGES:
514                                         fputs(fh, strcat("seta hud_panel_", panel_name, "_flip \"", cvar_string(strcat("hud_panel_", panel_name, "_flip")), "\"", "\n"));
515                                         break;
516                         }
517                         fputs(fh, "\n");
518                 }
519                 fputs(fh, strcat("menu_sync", "\n")); // force the menu to reread the cvars, so that the dialogs are updated
520
521                 print("^2Successfully exported to hud_", autocvar_hud_skin, "_", cfgname, ".cfg! (Note: It's saved in data/data/)\n");
522         }
523         fclose(fh);
524 }
525
526 const float hlBorderSize = 4;
527 const string hlBorder = "gfx/hud/default/border_highlighted";
528 const string hlBorder2 = "gfx/hud/default/border_highlighted2";
529 void HUD_Panel_HlBorder(float myBorder, vector color, float alpha)
530 {
531         drawfill(panel_pos - '1 1 0' * myBorder, panel_size + '2 2 0' * myBorder, '0 0.5 1', .5 * alpha, DRAWFLAG_NORMAL);
532         drawpic_tiled(panel_pos - '1 1 0' * myBorder, hlBorder, '8 1 0' * hlBorderSize, eX * (panel_size_x + 2 * myBorder) + eY * hlBorderSize, color, alpha, DRAWFLAG_NORMAL);
533         drawpic_tiled(panel_pos - '1 1 0' * myBorder + eY * (panel_size_y + 2 * myBorder - hlBorderSize), hlBorder, '8 1 0' * hlBorderSize, eX * (panel_size_x + 2 * myBorder) + eY * hlBorderSize, color, alpha, DRAWFLAG_NORMAL);
534         drawpic_tiled(panel_pos - '1 1 0' * myBorder + eY * hlBorderSize, hlBorder2, '1 8 0' * hlBorderSize, eY * (panel_size_y + 2 * myBorder - 2 * hlBorderSize) + eX * hlBorderSize, color, alpha, DRAWFLAG_NORMAL);
535         drawpic_tiled(panel_pos - '1 1 0' * myBorder + eY * hlBorderSize + eX * (panel_size_x + 2 * myBorder - hlBorderSize), hlBorder2, '1 8 0' * hlBorderSize, eY * (panel_size_y + 2 * myBorder - 2 * hlBorderSize) + eX * hlBorderSize, color, alpha, DRAWFLAG_NORMAL);
536 }
537
538 // draw the background/borders
539 #define HUD_Panel_DrawBg(alpha)\
540 if(panel_bg != "0")\
541         draw_BorderPicture(panel_pos - '1 1 0' * panel_bg_border, panel_bg, panel_size + '1 1 0' * 2 * panel_bg_border, panel_bg_color, panel_bg_alpha * alpha, '1 1 0' * (panel_bg_border/BORDER_MULTIPLIER));\
542 if(highlightedPanel_prev == active_panel && autocvar__hud_configure)\
543         HUD_Panel_HlBorder(panel_bg_border + 1.5 * hlBorderSize, '0 0.5 1', 0.25 * (1 - autocvar__menu_alpha) * alpha);
544
545 void HUD_Panel_DrawProgressBar(vector pos, float vertical, vector mySize, vector color, float alpha, float drawflag)
546 {
547         if(!alpha)
548                 return;
549
550         string pic;
551         if(vertical) {
552                 pic = strcat(hud_skin_path, "/statusbar_vertical");
553                 if(precache_pic(pic) == "") {
554                         pic = "gfx/hud/default/statusbar_vertical";
555                 }
556                 drawsubpic(pos, eY * min(mySize_y * 0.5, mySize_x) + eX * mySize_x, pic, '0 0 0', '1 0.25 0', color, alpha, drawflag);
557                 if(mySize_y/mySize_x > 2)
558                         drawsubpic(pos + eY * mySize_x, eY * (mySize_y - 2 * mySize_x) + eX * mySize_x, pic, '0 0.25 0', '1 0.5 0', color, alpha, drawflag);
559                 drawsubpic(pos + eY * mySize_y - eY * min(mySize_y * 0.5, mySize_x), eY * min(mySize_y * 0.5, mySize_x) + eX * mySize_x, pic, '0 0.75 0', '1 0.25 0', color, alpha, drawflag);
560         } else {
561                 pic = strcat(hud_skin_path, "/statusbar");
562                 if(precache_pic(pic) == "") {
563                         pic = "gfx/hud/default/statusbar";
564                 }
565                 drawsubpic(pos, eX * min(mySize_x * 0.5, mySize_y) + eY * mySize_y, pic, '0 0 0', '0.25 1 0', color, alpha, drawflag);
566                 if(mySize_x/mySize_y > 2)
567                         drawsubpic(pos + eX * mySize_y, eX * (mySize_x - 2 * mySize_y) + eY * mySize_y, pic, '0.25 0 0', '0.5 1 0', color, alpha, drawflag);
568                 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, alpha, drawflag);
569         }
570 }
571
572 void HUD_Panel_DrawHighlight(vector pos, vector mySize, vector color, float alpha, float drawflag)
573 {
574         if(!alpha)
575                 return;
576
577         string pic;
578         pic = strcat(hud_skin_path, "/num_leading");
579         if(precache_pic(pic) == "") {
580                 pic = "gfx/hud/default/num_leading";
581         }
582
583         drawsubpic(pos, eX * min(mySize_x * 0.5, mySize_y) + eY * mySize_y, pic, '0 0 0', '0.25 1 0', color, alpha, drawflag);
584         if(mySize_x/mySize_y > 2)
585                 drawsubpic(pos + eX * mySize_y, eX * (mySize_x - 2 * mySize_y) + eY * mySize_y, pic, '0.25 0 0', '0.5 1 0', color, alpha, drawflag);
586         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, alpha, drawflag);
587 }
588
589 // check if move will result in panel being moved into another panel. If so, return snapped vector, otherwise return the given vector
590 vector HUD_Panel_CheckMove(vector myPos, vector mySize)
591 {
592         float i;
593
594         vector myTarget;
595         myTarget = myPos;
596
597         vector targPos;
598         vector targSize;
599         vector myCenter;
600         vector targCenter;
601         myCenter = '0 0 0'; // shut up fteqcc, there IS a reference
602         targCenter = '0 0 0'; // shut up fteqcc, there IS a reference
603
604         for (i = 0; i < HUD_PANEL_NUM; ++i) {
605                 if(i == highlightedPanel || !panel_enabled)
606                         continue;
607
608                 HUD_Panel_UpdatePosSizeForId(i)
609
610                 panel_pos -= '1 1 0' * panel_bg_border;
611                 panel_size += '2 2 0' * panel_bg_border;
612
613                 if(myPos_y + mySize_y < panel_pos_y)
614                         continue;
615                 if(myPos_y > panel_pos_y + panel_size_y)
616                         continue;
617
618                 if(myPos_x + mySize_x < panel_pos_x)
619                         continue;
620                 if(myPos_x > panel_pos_x + panel_size_x)
621                         continue;
622
623                 // OK, there IS a collision.
624
625                 myCenter_x = myPos_x + 0.5 * mySize_x;
626                 myCenter_y = myPos_y + 0.5 * mySize_y;
627
628                 targCenter_x = panel_pos_x + 0.5 * panel_size_x;
629                 targCenter_y = panel_pos_y + 0.5 * panel_size_y;
630
631                 if(myCenter_x < targCenter_x && myCenter_y < targCenter_y) // top left (of the target panel)
632                 {
633                         if(myPos_x + mySize_x - panel_pos_x < myPos_y + mySize_y - panel_pos_y) // push it to the side
634                                 myTarget_x = panel_pos_x - mySize_x;
635                         else // push it upwards
636                                 myTarget_y = panel_pos_y - mySize_y;
637                 }
638                 else if(myCenter_x > targCenter_x && myCenter_y < targCenter_y) // top right
639                 {
640                         if(panel_pos_x + panel_size_x - myPos_x < myPos_y + mySize_y - panel_pos_y) // push it to the side
641                                 myTarget_x = panel_pos_x + panel_size_x;
642                         else // push it upwards
643                                 myTarget_y = panel_pos_y - mySize_y;
644                 }
645                 else if(myCenter_x < targCenter_x && myCenter_y > targCenter_y) // bottom left
646                 {
647                         if(myPos_x + mySize_x - panel_pos_x < panel_pos_y + panel_size_y - myPos_y) // push it to the side
648                                 myTarget_x = panel_pos_x - mySize_x;
649                         else // push it downwards
650                                 myTarget_y = panel_pos_y + panel_size_y;
651                 }
652                 else if(myCenter_x > targCenter_x && myCenter_y > targCenter_y) // bottom right
653                 {
654                         if(panel_pos_x + panel_size_x - myPos_x < panel_pos_y + panel_size_y - myPos_y) // push it to the side
655                                 myTarget_x = panel_pos_x + panel_size_x;
656                         else // push it downwards
657                                 myTarget_y = panel_pos_y + panel_size_y;
658                 }
659                 if(cvar("hud_configure_checkcollisions_debug"))
660                         drawfill(panel_pos, panel_size, '1 1 0', .3, DRAWFLAG_NORMAL);
661         }
662
663         return myTarget;
664 }
665
666 void HUD_Panel_SetPos(vector pos)
667 {
668         HUD_Panel_UpdatePosSizeForId(highlightedPanel)
669         vector mySize;
670         mySize = panel_size;
671
672         if(cvar("hud_configure_checkcollisions_debug"))
673                 drawfill(pos, mySize, '1 1 1', .2, DRAWFLAG_NORMAL);
674
675         if(autocvar_hud_configure_grid)
676         {
677                 pos_x = floor((pos_x/vid_conwidth)/bound(0.005, autocvar_hud_configure_grid_xsize, 0.2) + 0.5) * bound(0.005, autocvar_hud_configure_grid_xsize, 0.2) * vid_conwidth;
678                 pos_y = floor((pos_y/vid_conheight)/bound(0.005, autocvar_hud_configure_grid_ysize, 0.2) + 0.5) * bound(0.005, autocvar_hud_configure_grid_ysize, 0.2) * vid_conheight;
679         }
680
681         if(hud_configure_checkcollisions)
682                 pos = HUD_Panel_CheckMove(pos, mySize);
683
684         pos_x = bound(0, pos_x, vid_conwidth - mySize_x);
685         pos_y = bound(0, pos_y, vid_conheight - mySize_y);
686
687         string s;
688         s = strcat(ftos(pos_x/vid_conwidth), " ", ftos(pos_y/vid_conheight));
689
690         HUD_Panel_GetName(highlightedPanel);
691         cvar_set(strcat("hud_panel_", panel_name, "_pos"), s);
692 }
693
694 // check if resize will result in panel being moved into another panel. If so, return snapped vector, otherwise return the given vector
695 vector HUD_Panel_CheckResize(vector mySize, vector resizeorigin) {
696         float i;
697
698         float targBorder;
699         vector targPos;
700         vector targSize;
701         vector targEndPos;
702
703         vector dist;
704         float ratio;
705         ratio = mySize_x/mySize_y;
706
707         for (i = 0; i < HUD_PANEL_NUM; ++i) {
708                 if(i == highlightedPanel || !panel_enabled)
709                         continue;
710
711                 HUD_Panel_UpdatePosSizeForId(i)
712
713                 panel_pos -= '1 1 0' * panel_bg_border;
714                 panel_size += '2 2 0' * panel_bg_border;
715
716                 targEndPos = panel_pos + panel_size;
717
718                 // resizeorigin is WITHIN target panel, just abort any collision testing against that particular panel to produce expected behaviour!
719                 if(resizeorigin_x > panel_pos_x && resizeorigin_x < targEndPos_x && resizeorigin_y > panel_pos_y && resizeorigin_y < targEndPos_y)
720                         continue;
721
722                 if (resizeCorner == 1)
723                 {
724                         // check if this panel is on our way
725                         if (resizeorigin_x <= panel_pos_x)
726                                 continue;
727                         if (resizeorigin_y <= panel_pos_y)
728                                 continue;
729                         if (targEndPos_x <= resizeorigin_x - mySize_x)
730                                 continue;
731                         if (targEndPos_y <= resizeorigin_y - mySize_y)
732                                 continue;
733
734                         // there is a collision:
735                         // detect which side of the panel we are facing is actually limiting the resizing
736                         // (which side the resize direction finds for first) and reduce the size up to there
737                         //
738                         // dist is the distance between resizeorigin and the "analogous" point of the panel
739                         // in this case resizeorigin (bottom-right point) and the bottom-right point of the panel
740                         dist_x = resizeorigin_x - targEndPos_x;
741                         dist_y = resizeorigin_y - targEndPos_y;
742                         if (dist_y <= 0 || dist_x / dist_y > ratio)
743                                 mySize_x = min(mySize_x, dist_x);
744                         else
745                                 mySize_y = min(mySize_y, dist_y);
746                 }
747                 else if (resizeCorner == 2)
748                 {
749                         if (resizeorigin_x >= targEndPos_x)
750                                 continue;
751                         if (resizeorigin_y <= panel_pos_y)
752                                 continue;
753                         if (panel_pos_x >= resizeorigin_x + mySize_x)
754                                 continue;
755                         if (targEndPos_y <= resizeorigin_y - mySize_y)
756                                 continue;
757
758                         dist_x = panel_pos_x - resizeorigin_x;
759                         dist_y = resizeorigin_y - targEndPos_y;
760                         if (dist_y <= 0 || dist_x / dist_y > ratio)
761                                 mySize_x = min(mySize_x, dist_x);
762                         else
763                                 mySize_y = min(mySize_y, dist_y);
764                 }
765                 else if (resizeCorner == 3)
766                 {
767                         if (resizeorigin_x <= panel_pos_x)
768                                 continue;
769                         if (resizeorigin_y >= targEndPos_y)
770                                 continue;
771                         if (targEndPos_x <= resizeorigin_x - mySize_x)
772                                 continue;
773                         if (panel_pos_y >= resizeorigin_y + mySize_y)
774                                 continue;
775
776                         dist_x = resizeorigin_x - targEndPos_x;
777                         dist_y = panel_pos_y - resizeorigin_y;
778                         if (dist_y <= 0 || dist_x / dist_y > ratio)
779                                 mySize_x = min(mySize_x, dist_x);
780                         else
781                                 mySize_y = min(mySize_y, dist_y);
782                 }
783                 else if (resizeCorner == 4)
784                 {
785                         if (resizeorigin_x >= targEndPos_x)
786                                 continue;
787                         if (resizeorigin_y >= targEndPos_y)
788                                 continue;
789                         if (panel_pos_x >= resizeorigin_x + mySize_x)
790                                 continue;
791                         if (panel_pos_y >= resizeorigin_y + mySize_y)
792                                 continue;
793
794                         dist_x = panel_pos_x - resizeorigin_x;
795                         dist_y = panel_pos_y - resizeorigin_y;
796                         if (dist_y <= 0 || dist_x / dist_y > ratio)
797                                 mySize_x = min(mySize_x, dist_x);
798                         else
799                                 mySize_y = min(mySize_y, dist_y);
800                 }
801                 if(cvar("hud_configure_checkcollisions_debug"))
802                         drawfill(panel_pos, panel_size, '1 1 0', .3, DRAWFLAG_NORMAL);
803         }
804
805         return mySize;
806 }
807
808 void HUD_Panel_SetPosSize(vector mySize)
809 {
810         HUD_Panel_UpdatePosSizeForId(highlightedPanel)
811         vector resizeorigin;
812         resizeorigin = panel_click_resizeorigin;
813         vector myPos;
814
815         // minimum panel size cap
816         mySize_x = max(0.025 * vid_conwidth, mySize_x);
817         mySize_y = max(0.025 * vid_conheight, mySize_y);
818
819         if(highlightedPanel == HUD_PANEL_CHAT) // some panels have their own restrictions, like the chat panel (which actually only moves the engine chat print around). Looks bad if it's too small.
820         {
821                 mySize_x = max(17 * cvar("con_chatsize"), mySize_x);
822                 mySize_y = max(2 * cvar("con_chatsize") + 2 * panel_bg_padding, mySize_y);
823         }
824
825         // collision testing|
826         // -----------------+
827
828         // we need to know pos at this stage, but it might still change later if we hit a screen edge/other panel (?)
829         if(resizeCorner == 1) {
830                 myPos_x = resizeorigin_x - mySize_x;
831                 myPos_y = resizeorigin_y - mySize_y;
832         } else if(resizeCorner == 2) {
833                 myPos_x = resizeorigin_x;
834                 myPos_y = resizeorigin_y - mySize_y;
835         } else if(resizeCorner == 3) {
836                 myPos_x = resizeorigin_x - mySize_x;
837                 myPos_y = resizeorigin_y;
838         } else { // resizeCorner == 4
839                 myPos_x = resizeorigin_x;
840                 myPos_y = resizeorigin_y;
841         }
842
843         // left/top screen edges
844         if(myPos_x < 0)
845                 mySize_x = mySize_x + myPos_x;
846         if(myPos_y < 0)
847                 mySize_y = mySize_y + myPos_y;
848
849         // bottom/right screen edges
850         if(myPos_x + mySize_x > vid_conwidth)
851                 mySize_x = vid_conwidth - myPos_x;
852         if(myPos_y + mySize_y > vid_conheight)
853                 mySize_y = vid_conheight - myPos_y;
854
855         if(cvar("hud_configure_checkcollisions_debug"))
856                 drawfill(myPos, mySize, '1 1 1', .2, DRAWFLAG_NORMAL);
857
858         // before checkresize, otherwise panel can be snapped partially inside another panel or panel aspect ratio can be broken
859         if(autocvar_hud_configure_grid)
860         {
861                 mySize_x = floor((mySize_x/vid_conwidth)/bound(0.005, autocvar_hud_configure_grid_xsize, 0.2) + 0.5) * bound(0.005, autocvar_hud_configure_grid_xsize, 0.2) * vid_conwidth;
862                 mySize_y = floor((mySize_y/vid_conheight)/bound(0.005, autocvar_hud_configure_grid_ysize, 0.2) + 0.5) * bound(0.005, autocvar_hud_configure_grid_ysize, 0.2) * vid_conheight;
863         }
864
865         if(hud_configure_checkcollisions)
866                 mySize = HUD_Panel_CheckResize(mySize, resizeorigin);
867
868         // minimum panel size cap, do this once more so we NEVER EVER EVER have a panel smaller than this, JUST IN CASE above code still makes the panel eg negative (impossible to resize back without changing cvars manually then)
869         mySize_x = max(0.025 * vid_conwidth, mySize_x);
870         mySize_y = max(0.025 * vid_conheight, mySize_y);
871
872         // do another pos check, as size might have changed by now
873         if(resizeCorner == 1) {
874                 myPos_x = resizeorigin_x - mySize_x;
875                 myPos_y = resizeorigin_y - mySize_y;
876         } else if(resizeCorner == 2) {
877                 myPos_x = resizeorigin_x;
878                 myPos_y = resizeorigin_y - mySize_y;
879         } else if(resizeCorner == 3) {
880                 myPos_x = resizeorigin_x - mySize_x;
881                 myPos_y = resizeorigin_y;
882         } else { // resizeCorner == 4
883                 myPos_x = resizeorigin_x;
884                 myPos_y = resizeorigin_y;
885         }
886
887         if(cvar("hud_configure_checkcollisions_debug"))
888                 drawfill(myPos, mySize, '0 1 0', .3, DRAWFLAG_NORMAL);
889
890         HUD_Panel_GetName(highlightedPanel);
891         string s;
892         s = strcat(ftos(mySize_x/vid_conwidth), " ", ftos(mySize_y/vid_conheight));
893         cvar_set(strcat("hud_panel_", panel_name, "_size"), s);
894
895         s = strcat(ftos(myPos_x/vid_conwidth), " ", ftos(myPos_y/vid_conheight));
896         cvar_set(strcat("hud_panel_", panel_name, "_pos"), s);
897 }
898
899 float mouseClicked;
900 float prevMouseClicked; // previous state
901 float prevMouseClickedTime; // time during previous mouse click, to check for doubleclicks
902 vector prevMouseClickedPos; // pos during previous mouse click, to check for doubleclicks
903
904 float pressed_key_time;
905 void HUD_Panel_Arrow_Action(float nPrimary)
906 {
907         if (highlightedPanel_prev == -1 || mouseClicked)
908                 return;
909
910         hud_configure_checkcollisions = (!(hudShiftState & S_CTRL) && cvar("hud_configure_checkcollisions"));
911
912         float step;
913         if(autocvar_hud_configure_grid)
914         {
915                 if (nPrimary == K_UPARROW || nPrimary == K_DOWNARROW)
916                 {
917                         if (hudShiftState & S_SHIFT)
918                                 step = bound(0.005, autocvar_hud_configure_grid_ysize, 0.2) * vid_conheight;
919                         else
920                                 step = 2 * bound(0.005, autocvar_hud_configure_grid_ysize, 0.2) * vid_conheight;
921                 }
922                 else
923                 {
924                         if (hudShiftState & S_SHIFT)
925                                 step = bound(0.005, autocvar_hud_configure_grid_xsize, 0.2) * vid_conwidth;
926                         else
927                                 step = 2 * bound(0.005, autocvar_hud_configure_grid_xsize, 0.2) * vid_conwidth;
928                 }
929         }
930         else
931         {
932                 if (nPrimary == K_UPARROW || nPrimary == K_DOWNARROW)
933                         step = vid_conheight;
934                 else
935                         step = vid_conwidth;
936                 if (hudShiftState & S_SHIFT)
937                         step = (step / 256); // more precision
938                 else
939                         step = (step / 64) * (1 + 2 * (time - pressed_key_time));
940         }
941
942         highlightedPanel = highlightedPanel_prev;
943
944         HUD_Panel_UpdatePosSizeForId(highlightedPanel)
945
946         vector prev_pos, prev_size;
947         prev_pos = panel_pos;
948         prev_size = panel_size;
949
950         if (hudShiftState & S_ALT) // resize
951         {
952                 highlightedAction = 1;
953                 if(nPrimary == K_UPARROW)
954                         resizeCorner = 1;
955                 else if(nPrimary == K_RIGHTARROW)
956                         resizeCorner = 2;
957                 else if(nPrimary == K_LEFTARROW)
958                         resizeCorner = 3;
959                 else // if(nPrimary == K_DOWNARROW)
960                         resizeCorner = 4;
961
962                 // ctrl+arrow reduces the size, instead of increasing it
963                 // Note that ctrl disables collisions check too, but it's fine
964                 // since we don't collide with anything reducing the size
965                 if (hudShiftState & S_CTRL) {
966                         step = -step;
967                         resizeCorner = 5 - resizeCorner;
968                 }
969
970                 vector mySize;
971                 mySize = panel_size;
972                 panel_click_resizeorigin = panel_pos;
973                 if(resizeCorner == 1) {
974                         panel_click_resizeorigin += mySize;
975                         mySize_y += step;
976                 } else if(resizeCorner == 2) {
977                         panel_click_resizeorigin_y += mySize_y;
978                         mySize_x += step;
979                 } else if(resizeCorner == 3) {
980                         panel_click_resizeorigin_x += mySize_x;
981                         mySize_x += step;
982                 } else { // resizeCorner == 4
983                         mySize_y += step;
984                 }
985                 HUD_Panel_SetPosSize(mySize);
986         }
987         else // move
988         {
989                 highlightedAction = 2;
990                 vector pos;
991                 pos = panel_pos;
992                 if(nPrimary == K_UPARROW)
993                         pos_y -= step;
994                 else if(nPrimary == K_DOWNARROW)
995                         pos_y += step;
996                 else if(nPrimary == K_LEFTARROW)
997                         pos_x -= step;
998                 else // if(nPrimary == K_RIGHTARROW)
999                         pos_x += step;
1000
1001                 HUD_Panel_SetPos(pos);
1002         }
1003
1004         HUD_Panel_UpdatePosSizeForId(highlightedPanel)
1005
1006         if (prev_pos != panel_pos || prev_size != panel_size)
1007         {
1008                 // backup!
1009                 panel_pos_backup = prev_pos;
1010                 panel_size_backup = prev_size;
1011                 highlightedPanel_backup = highlightedPanel;
1012         }
1013 }
1014
1015 float HUD_Panel_InputEvent(float bInputType, float nPrimary, float nSecondary)
1016 {
1017         if(!autocvar__hud_configure)
1018                 return false;
1019
1020         // allow console bind to work
1021         string con_keys;
1022         float keys;
1023         con_keys = findkeysforcommand("toggleconsole");
1024         keys = tokenize(con_keys);
1025
1026         float hit_con_bind, i;
1027         for (i = 0; i < keys; ++i)
1028         {
1029                 if(nPrimary == stof(argv(i)))
1030                         hit_con_bind = 1;
1031         }
1032
1033         if(bInputType == 0) {
1034                 if(nPrimary == K_ALT) hudShiftState |= S_ALT;
1035                 if(nPrimary == K_CTRL) hudShiftState |= S_CTRL;
1036                 if(nPrimary == K_SHIFT) hudShiftState |= S_SHIFT;
1037         }
1038         else if(bInputType == 1) {
1039                 if(nPrimary == K_ALT) hudShiftState -= (hudShiftState & S_ALT);
1040                 if(nPrimary == K_CTRL) hudShiftState -= (hudShiftState & S_CTRL);
1041                 if(nPrimary == K_SHIFT) hudShiftState -= (hudShiftState & S_SHIFT);
1042         }
1043
1044         if(nPrimary == K_MOUSE1)
1045         {
1046                 if(bInputType == 0) { // key pressed
1047                         mouseClicked = 1;
1048                         return true;
1049                 }
1050                 else if(bInputType == 1) {// key released
1051                         mouseClicked = 0;
1052                         return true;
1053                 }
1054         }
1055         else if(nPrimary == K_ESCAPE)
1056         {
1057                 if (bInputType == 1)
1058                         return true;
1059                 menu_enabled = 1;
1060                 menu_enabled_time = time;
1061                 localcmd("menu_showhudexit\n");
1062         }
1063         else if(hudShiftState & S_CTRL)
1064         {
1065                 if (mouseClicked)
1066                         return true;
1067
1068                 if(nPrimary == K_SPACE) // enable/disable highlighted panel or dock
1069                 {
1070                         if (bInputType == 1)
1071                                 return true;
1072
1073                         if (highlightedPanel_prev != -1)
1074                                 cvar_set(strcat("hud_panel_", panel_name), ftos(!(panel_enabled)));
1075                         else
1076                                 cvar_set(strcat("hud_dock"), (autocvar_hud_dock == "") ? "dock" : "");
1077                 }
1078                 if(nPrimary == 'c') // copy highlighted panel size
1079                 {
1080                         if (bInputType == 1)
1081                                 return true;
1082
1083                         if (highlightedPanel_prev != -1)
1084                         {
1085                                 panel_size_copied = panel_size;
1086                                 highlightedPanel_copied = highlightedPanel_prev;
1087                         }
1088                 }
1089                 else if(nPrimary == 'v') // past copied size on the highlighted panel
1090                 {
1091                         if (bInputType == 1)
1092                                 return true;
1093
1094                         if (highlightedPanel_copied == -1 || highlightedPanel_prev == -1)
1095                                 return true;
1096
1097                         HUD_Panel_UpdatePosSizeForId(highlightedPanel_prev)
1098
1099                         // reduce size if it'd go beyond screen boundaries
1100                         vector tmp_size = panel_size_copied;
1101                         if (panel_pos_x + panel_size_copied_x > vid_conwidth)
1102                                 tmp_size_x = vid_conwidth - panel_pos_x;
1103                         if (panel_pos_y + panel_size_copied_y > vid_conheight)
1104                                 tmp_size_y = vid_conheight - panel_pos_y;
1105
1106                         if (panel_size == tmp_size)
1107                                 return true;
1108
1109                         // backup first!
1110                         panel_pos_backup = panel_pos;
1111                         panel_size_backup = panel_size;
1112                         highlightedPanel_backup = highlightedPanel_prev;
1113
1114                         string s;
1115                         s = strcat(ftos(tmp_size_x/vid_conwidth), " ", ftos(tmp_size_y/vid_conheight));
1116                         cvar_set(strcat("hud_panel_", panel_name, "_size"), s);
1117                 }
1118                 else if(nPrimary == 'z') // undo last action
1119                 {
1120                         if (bInputType == 1)
1121                                 return true;
1122                         //restore previous values
1123                         if (highlightedPanel_backup != -1)
1124                         {
1125                                 HUD_Panel_GetName(highlightedPanel_backup)
1126                                 string s;
1127                                 s = strcat(ftos(panel_pos_backup_x/vid_conwidth), " ", ftos(panel_pos_backup_y/vid_conheight));
1128                                 cvar_set(strcat("hud_panel_", panel_name, "_pos"), s);
1129                                 s = strcat(ftos(panel_size_backup_x/vid_conwidth), " ", ftos(panel_size_backup_y/vid_conheight));
1130                                 cvar_set(strcat("hud_panel_", panel_name, "_size"), s);
1131                                 highlightedPanel_backup = -1;
1132                         }
1133                 }
1134         }
1135         else if(nPrimary == K_UPARROW || nPrimary == K_DOWNARROW || nPrimary == K_LEFTARROW || nPrimary == K_RIGHTARROW)
1136         {
1137                 if (bInputType == 1)
1138                 {
1139                         pressed_key_time = 0;
1140                         return true;
1141                 }
1142                 else if (pressed_key_time == 0)
1143                         pressed_key_time = time;
1144
1145                 HUD_Panel_Arrow_Action(nPrimary); //move or resize panel
1146         }
1147         else if(hit_con_bind)
1148                 return false;
1149
1150         return true; // Suppress ALL other input
1151 }
1152
1153 float HUD_Panel_HighlightCheck()
1154 {
1155         float i, j, border;
1156         vector panelPos;
1157         vector panelSize;
1158
1159         while(j <= HUD_PANEL_NUM)
1160         {
1161                 i = panel_order[j];
1162                 j += 1;
1163
1164                 HUD_Panel_UpdatePosSizeForId(i)
1165
1166                 panelPos = panel_pos;
1167                 panelSize = panel_size;
1168                 border = max(8, panel_bg_border); // FORCED border so a small border size doesn't mean you can't resize
1169
1170                 // move
1171                 if(mousepos_x >= panelPos_x && mousepos_y >= panelPos_y && mousepos_x <= panelPos_x + panelSize_x && mousepos_y <= panelPos_y + panelSize_y)
1172                 {
1173                         return 1;
1174                 }
1175                 // resize from topleft border
1176                 else if(mousepos_x >= panelPos_x - border && mousepos_y >= panelPos_y - border && mousepos_x <= panelPos_x + 0.5 * panelSize_x && mousepos_y <= panelPos_y + 0.5 * panelSize_y)
1177                 {
1178                         return 2;
1179                 }
1180                 // resize from topright border
1181                 else if(mousepos_x >= panelPos_x + 0.5 * panelSize_x && mousepos_y >= panelPos_y - border && mousepos_x <= panelPos_x + panelSize_x + border && mousepos_y <= panelPos_y + 0.5 * panelSize_y)
1182                 {
1183                         return 3;
1184                 }
1185                 // resize from bottomleft border
1186                 else if(mousepos_x >= panelPos_x - border && mousepos_y >= panelPos_y + 0.5 * panelSize_y && mousepos_x <= panelPos_x + 0.5 * panelSize_x && mousepos_y <= panelPos_y + panelSize_y + border)
1187                 {
1188                         return 3;
1189                 }
1190                 // resize from bottomright border
1191                 else if(mousepos_x >= panelPos_x + 0.5 * panelSize_x && mousepos_y >= panelPos_y + 0.5 * panelSize_y && mousepos_x <= panelPos_x + panelSize_x + border && mousepos_y <= panelPos_y + panelSize_y + border)
1192                 {
1193                         return 2;
1194                 }
1195         }
1196         return 0;
1197 }
1198
1199 // move a panel to the beginning of the panel order array (which means it gets drawn last, on top of everything else)
1200 void HUD_Panel_FirstInDrawQ(float id)
1201 {
1202         float i;
1203         var float place = -1;
1204         // find out where in the array our current id is, save into place
1205         for(i = 0; i < HUD_PANEL_NUM; ++i)
1206         {
1207                 if(panel_order[i] == id)
1208                 {
1209                         place = i;
1210                         break;
1211                 }
1212         }
1213         // place last if we didn't find a place for it yet (probably new panel, or screwed up cvar)
1214         if(place == -1)
1215                 place = HUD_PANEL_NUM - 1;
1216
1217         // move all ids up by one step in the array until "place"
1218         for(i = place; i > 0; --i)
1219         {
1220                 panel_order[i] = panel_order[i-1];
1221         }
1222         // now save the new top id
1223         panel_order[0] = id;
1224         
1225         // let's save them into the cvar by some strcat trickery
1226         string s;
1227         for(i = 0; i < HUD_PANEL_NUM; ++i)
1228         {
1229                 s = strcat(s, ftos(panel_order[i]), " ");
1230         }
1231         cvar_set("_hud_panelorder", s);
1232         if(hud_panelorder_prev)
1233                 strunzone(hud_panelorder_prev);
1234         hud_panelorder_prev = strzone(autocvar__hud_panelorder); // prevent HUD_Main from doing useless update, we already updated here
1235 }
1236
1237 void HUD_Panel_Highlight()
1238 {
1239         float i, j, border;
1240         vector panelPos;
1241         vector panelSize;
1242
1243         while(j <= HUD_PANEL_NUM)
1244         {
1245                 i = panel_order[j];
1246                 j += 1;
1247
1248                 HUD_Panel_UpdatePosSizeForId(i)
1249
1250                 panelPos = panel_pos;
1251                 panelSize = panel_size;
1252                 border = max(8, panel_bg_border); // FORCED border so a small border size doesn't mean you can't resize
1253
1254                 // move
1255                 if(mousepos_x >= panelPos_x && mousepos_y >= panelPos_y && mousepos_x <= panelPos_x + panelSize_x && mousepos_y <= panelPos_y + panelSize_y)
1256                 {
1257                         highlightedPanel = i;
1258                         HUD_Panel_FirstInDrawQ(i);
1259                         highlightedAction = 1;
1260                         panel_click_distance = mousepos - panelPos;
1261                         return;
1262                 }
1263                 // resize from topleft border
1264                 else if(mousepos_x >= panelPos_x - border && mousepos_y >= panelPos_y - border && mousepos_x <= panelPos_x + 0.5 * panelSize_x && mousepos_y <= panelPos_y + 0.5 * panelSize_y)
1265                 {
1266                         highlightedPanel = i;
1267                         HUD_Panel_FirstInDrawQ(i);
1268                         highlightedAction = 2;
1269                         resizeCorner = 1;
1270                         panel_click_distance = mousepos - panelPos;
1271                         panel_click_resizeorigin = panelPos + panelSize;
1272                         return;
1273                 }
1274                 // resize from topright border
1275                 else if(mousepos_x >= panelPos_x + 0.5 * panelSize_x && mousepos_y >= panelPos_y - border && mousepos_x <= panelPos_x + panelSize_x + border && mousepos_y <= panelPos_y + 0.5 * panelSize_y)
1276                 {
1277                         highlightedPanel = i;
1278                         HUD_Panel_FirstInDrawQ(i);
1279                         highlightedAction = 2;
1280                         resizeCorner = 2;
1281                         panel_click_distance_x = panelSize_x - mousepos_x + panelPos_x;
1282                         panel_click_distance_y = mousepos_y - panelPos_y;
1283                         panel_click_resizeorigin = panelPos + eY * panelSize_y;
1284                         return;
1285                 }
1286                 // resize from bottomleft border
1287                 else if(mousepos_x >= panelPos_x - border && mousepos_y >= panelPos_y + 0.5 * panelSize_y && mousepos_x <= panelPos_x + 0.5 * panelSize_x && mousepos_y <= panelPos_y + panelSize_y + border)
1288                 {
1289                         highlightedPanel = i;
1290                         HUD_Panel_FirstInDrawQ(i);
1291                         highlightedAction = 2;
1292                         resizeCorner = 3;
1293                         panel_click_distance_x = mousepos_x - panelPos_x;
1294                         panel_click_distance_y = panelSize_y - mousepos_y + panelPos_y;
1295                         panel_click_resizeorigin = panelPos + eX * panelSize_x;
1296                         return;
1297                 }
1298                 // resize from bottomright border
1299                 else if(mousepos_x >= panelPos_x + 0.5 * panelSize_x && mousepos_y >= panelPos_y + 0.5 * panelSize_y && mousepos_x <= panelPos_x + panelSize_x + border && mousepos_y <= panelPos_y + panelSize_y + border)
1300                 {
1301                         highlightedPanel = i;
1302                         HUD_Panel_FirstInDrawQ(i);
1303                         highlightedAction = 2;
1304                         resizeCorner = 4;
1305                         panel_click_distance = panelSize - mousepos + panelPos;
1306                         panel_click_resizeorigin = panelPos;
1307                         return;
1308                 }
1309                 else
1310                 {
1311                         highlightedPanel_prev = -1;
1312                 }
1313         }
1314 }
1315
1316 float highlightcheck;
1317 vector prev_pos, prev_size;
1318 void HUD_Panel_Mouse()
1319 {
1320         // TODO: needs better check... is there any float that contains the current state of the menu? _menu_alpha isn't apparently updated the frame the menu gets enabled
1321         if (autocvar__menu_alpha == 0 && time - menu_enabled_time > 0.5)
1322                 menu_enabled = 0;
1323
1324         /*
1325         print("menu_enabled: ", ftos(menu_enabled), "\n");
1326         print("Highlighted: ", ftos(highlightedPanel), "\n");
1327         print("Menu alpha: ", cvar_string("_menu_alpha"), "\n");
1328         */
1329
1330         // instantly hide the editor cursor if we open the HUDExit dialog
1331         // as hud_fade_alpha doesn't decrease to 0 in this case
1332         // TODO: find a way to fade the cursor out even in this case
1333         if(menu_enabled == 1 || (menu_enabled == 2 && !hud_fade_alpha))
1334                 return;
1335
1336         if(mouseClicked == 0 && menu_enabled != 2 && highlightedPanel >= 0) { // don't reset these variables in menu_enabled mode 2!
1337                 highlightedPanel = -1;
1338                 highlightedAction = 0;
1339         }
1340         if(highlightedPanel != -1)
1341                 highlightedPanel_prev = highlightedPanel;
1342
1343         mousepos = mousepos + getmousepos() * cvar("menu_mouse_speed");
1344
1345         mousepos_x = bound(0, mousepos_x, vid_conwidth);
1346         mousepos_y = bound(0, mousepos_y, vid_conheight);
1347
1348         if(mouseClicked)
1349         {
1350                 if(prevMouseClicked == 0)
1351                 {
1352                         HUD_Panel_Highlight(); // sets highlightedPanel, highlightedAction, panel_click_distance, panel_click_resizeorigin
1353                                                                         // and calls HUD_Panel_UpdatePosSizeForId() for the highlighted panel
1354                         prev_pos = panel_pos;
1355                         prev_size = panel_size;
1356                 }
1357                 else
1358                         HUD_Panel_UpdatePosSizeForId(highlightedPanel)
1359
1360                 if (prev_pos != panel_pos || prev_size != panel_size)
1361                 {
1362                         hud_configure_checkcollisions = (!(hudShiftState & S_CTRL) && autocvar_hud_configure_checkcollisions);
1363                         // backup!
1364                         panel_pos_backup = prev_pos;
1365                         panel_size_backup = prev_size;
1366                         highlightedPanel_backup = highlightedPanel;
1367                 }
1368                 else
1369                         // in case the clicked panel is inside another panel and we aren't
1370                         // moving it, avoid the immediate "fix" of its position/size
1371                         // (often unwanted and hateful) by disabling collisions check
1372                         hud_configure_checkcollisions = false;
1373
1374                 if(highlightedAction == 1)
1375                         HUD_Panel_SetPos(mousepos - panel_click_distance);
1376                 else if(highlightedAction == 2)
1377                 {
1378                         vector mySize;
1379                         if(resizeCorner == 1) {
1380                                 mySize_x = panel_click_resizeorigin_x - (mousepos_x - panel_click_distance_x);
1381                                 mySize_y = panel_click_resizeorigin_y - (mousepos_y - panel_click_distance_y);
1382                         } else if(resizeCorner == 2) {
1383                                 mySize_x = mousepos_x + panel_click_distance_x - panel_click_resizeorigin_x;
1384                                 mySize_y = panel_click_distance_y + panel_click_resizeorigin_y - mousepos_y;
1385                         } else if(resizeCorner == 3) {
1386                                 mySize_x = panel_click_resizeorigin_x + panel_click_distance_x - mousepos_x;
1387                                 mySize_y = mousepos_y + panel_click_distance_y - panel_click_resizeorigin_y;
1388                         } else { // resizeCorner == 4
1389                                 mySize_x = mousepos_x - (panel_click_resizeorigin_x - panel_click_distance_x);
1390                                 mySize_y = mousepos_y - (panel_click_resizeorigin_y - panel_click_distance_y);
1391                         }
1392                         HUD_Panel_SetPosSize(mySize);
1393                 }
1394
1395                 // doubleclick check
1396                 if(time - prevMouseClickedTime < 0.4 && prevMouseClicked == 0 && prevMouseClickedPos == mousepos && highlightedPanel >= 0)
1397                 {
1398                         mouseClicked = 0; // to prevent spam, I guess.
1399                         menu_enabled = 2;
1400                         menu_enabled_time = time;
1401                         HUD_Panel_GetName(highlightedPanel)
1402                         localcmd("menu_showhudoptions ", panel_name, "\n");
1403                         return;
1404                 }
1405                 if(prevMouseClicked == 0)
1406                 {
1407                         prevMouseClickedTime = time;
1408                         prevMouseClickedPos = mousepos;
1409                 }
1410         }
1411         else
1412         {
1413                 highlightcheck = HUD_Panel_HighlightCheck();
1414         }
1415         // draw cursor after performing move/resize to have the panel pos/size updated before highlightcheck
1416         string cursor;
1417         vector cursorsize;
1418         cursorsize = '32 32 0';
1419
1420         if(highlightcheck == 0)
1421                 drawpic(mousepos, strcat("gfx/menu/", cvar_string("menu_skin"), "/cursor.tga"), '32 32 0', '1 1 1', hud_fade_alpha, DRAWFLAG_NORMAL);
1422         else if(highlightcheck == 1)
1423                 drawpic(mousepos - cursorsize * 0.5, strcat("gfx/menu/", cvar_string("menu_skin"), "/cursor_move.tga"), '32 32 0', '1 1 1', hud_fade_alpha, DRAWFLAG_NORMAL);
1424         else if(highlightcheck == 2)
1425                 drawpic(mousepos - cursorsize * 0.5, strcat("gfx/menu/", cvar_string("menu_skin"), "/cursor_resize.tga"), '32 32 0', '1 1 1', hud_fade_alpha, DRAWFLAG_NORMAL);
1426         else
1427                 drawpic(mousepos - cursorsize * 0.5, strcat("gfx/menu/", cvar_string("menu_skin"), "/cursor_resize2.tga"), '32 32 0', '1 1 1', hud_fade_alpha, DRAWFLAG_NORMAL);
1428
1429         prevMouseClicked = mouseClicked;
1430 }
1431
1432 // Weapon icons (#0)
1433 //
1434 float weaponspace[10];
1435 #define HUD_Weapons_Clear()\
1436         float idx;\
1437         for(idx = 0; idx < 10; ++idx)\
1438                 weaponspace[idx] = 0;
1439
1440 entity weaponorder[WEP_MAXCOUNT];
1441 void weaponorder_swap(float i, float j, entity pass)
1442 {
1443         entity h;
1444         h = weaponorder[i];
1445         weaponorder[i] = weaponorder[j];
1446         weaponorder[j] = h;
1447 }
1448
1449 string weaponorder_cmp_str_save;
1450 string weaponorder_cmp_str;
1451 float weaponorder_cmp(float i, float j, entity pass)
1452 {
1453         float ai, aj;
1454         ai = strstrofs(weaponorder_cmp_str, sprintf(" %d ", weaponorder[i].weapon), 0);
1455         aj = strstrofs(weaponorder_cmp_str, sprintf(" %d ", weaponorder[j].weapon), 0);
1456         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)
1457 }
1458
1459 float GetAmmoStat(float i)
1460 {
1461         switch(i)
1462         {
1463                 case 0: return STAT_SHELLS;
1464                 case 1: return STAT_NAILS;
1465                 case 2: return STAT_ROCKETS;
1466                 case 3: return STAT_CELLS;
1467                 case 4: return STAT_FUEL;
1468                 default: return -1;
1469         }
1470 }
1471
1472 float GetAmmoTypeForWep(float i)
1473 {
1474         switch(i)
1475         {
1476                 case WEP_SHOTGUN: return 0;
1477                 case WEP_UZI: return 1;
1478                 case WEP_CAMPINGRIFLE: return 1;
1479                 case WEP_GRENADE_LAUNCHER: return 2;
1480                 case WEP_MINE_LAYER: return 2;
1481                 case WEP_ELECTRO: return 3;
1482                 case WEP_CRYLINK: return 3;
1483                 case WEP_HLAC: return 3;
1484                 case WEP_MINSTANEX: return 3;
1485                 case WEP_NEX: return 3;
1486                 case WEP_HAGAR: return 2;
1487                 case WEP_ROCKET_LAUNCHER: return 2;
1488                 case WEP_SEEKER: return 2;
1489                 case WEP_FIREBALL: return 4;
1490                 case WEP_HOOK: return 3;
1491                 default: return -1;
1492         }
1493 }
1494
1495 void HUD_Weapons(void)
1496 {
1497         if(!autocvar_hud_panel_weapons && !autocvar__hud_configure)
1498                 return;
1499
1500         float timeout = cvar("hud_panel_weapons_timeout");
1501         float timeout_effect_length, timein_effect_length;
1502         if (cvar("hud_panel_weapons_timeout_effect") == 0)
1503         {
1504                 timeout_effect_length = 0;
1505                 timein_effect_length = 0;
1506         }
1507         else
1508         {
1509                 timeout_effect_length = 0.75;
1510                 timein_effect_length = 0.375;
1511         }
1512
1513         if (timeout && time >= weapontime + timeout + timeout_effect_length && !autocvar__hud_configure)
1514         {
1515                 weaponprevtime = time;
1516                 return;
1517         }
1518
1519         active_panel = HUD_PANEL_WEAPONS;
1520         HUD_Panel_UpdateCvars(weapons);
1521
1522         if (timeout && time >= weapontime + timeout && !autocvar__hud_configure)
1523         {
1524                 float f = (time - (weapontime + timeout)) / timeout_effect_length;
1525                 if (cvar("hud_panel_weapons_timeout_effect"))
1526                 {
1527                         panel_bg_alpha *= (1 - f);
1528                         panel_fg_alpha *= (1 - f);
1529                 }
1530                 if (cvar("hud_panel_weapons_timeout_effect") == 1)
1531                 {
1532                         f *= f; // for a cooler movement
1533                         vector center;
1534                         center_x = panel_pos_x + panel_size_x/2;
1535                         center_y = panel_pos_y + panel_size_y/2;
1536                         float screen_ar = vid_conwidth/vid_conheight;
1537                         if (center_x/center_y < screen_ar) //bottom left
1538                         {
1539                                 if ((vid_conwidth - center_x)/center_y < screen_ar) //bottom
1540                                         panel_pos_y += f * (vid_conheight - panel_pos_y);
1541                                 else //left
1542                                         panel_pos_x -= f * (panel_pos_x + panel_size_x);
1543                         }
1544                         else //top right
1545                         {
1546                                 if ((vid_conwidth - center_x)/center_y < screen_ar) //right
1547                                         panel_pos_x += f * (vid_conwidth - panel_pos_x);
1548                                 else //top
1549                                         panel_pos_y -= f * (panel_pos_y + panel_size_y);
1550                         }
1551                 }
1552                 weaponprevtime = time - (1 - f) * timein_effect_length;
1553         }
1554         else if (timeout && time < weaponprevtime + timein_effect_length && !autocvar__hud_configure)
1555         {
1556                 float f = (time - weaponprevtime) / timein_effect_length;
1557                 if (cvar("hud_panel_weapons_timeout_effect"))
1558                 {
1559                         panel_bg_alpha *= (f);
1560                         panel_fg_alpha *= (f);
1561                 }
1562                 if (cvar("hud_panel_weapons_timeout_effect") == 1)
1563                 {
1564                         f *= f; // for a cooler movement
1565                         f = 1 - f;
1566                         vector center;
1567                         center_x = panel_pos_x + panel_size_x/2;
1568                         center_y = panel_pos_y + panel_size_y/2;
1569                         float screen_ar = vid_conwidth/vid_conheight;
1570                         if (center_x/center_y < screen_ar) //bottom left
1571                         {
1572                                 if ((vid_conwidth - center_x)/center_y < screen_ar) //bottom
1573                                         panel_pos_y += f * (vid_conheight - panel_pos_y);
1574                                 else //left
1575                                         panel_pos_x -= f * (panel_pos_x + panel_size_x);
1576                         }
1577                         else //top right
1578                         {
1579                                 if ((vid_conwidth - center_x)/center_y < screen_ar) //right
1580                                         panel_pos_x += f * (vid_conwidth - panel_pos_x);
1581                                 else //top
1582                                         panel_pos_y -= f * (panel_pos_y + panel_size_y);
1583                         }
1584                 }
1585         }
1586
1587         float i, weapid, fade, weapon_stats, weapon_number, weapon_cnt;
1588         weapon_cnt = 0;
1589         for(i = WEP_FIRST; i <= WEP_LAST; ++i)
1590         {
1591                 self = get_weaponinfo(i);
1592                 if(self.impulse >= 0)
1593                         ++weapon_cnt;
1594         }
1595
1596         // TODO make this configurable
1597         weaponorder_cmp_str = strcat(" ", weaponorder_byimpulse, " ");
1598
1599         if(weaponorder_cmp_str != weaponorder_cmp_str_save)
1600         {
1601                 if(weaponorder_cmp_str_save)
1602                         strunzone(weaponorder_cmp_str_save);
1603                 weaponorder_cmp_str_save = strzone(weaponorder_cmp_str);
1604                 weapon_cnt = 0;
1605                 for(i = WEP_FIRST; i <= WEP_LAST; ++i)
1606                 {
1607                         self = get_weaponinfo(i);
1608                         if(self.impulse >= 0)
1609                         {
1610                                 weaponorder[weapon_cnt] = self;
1611                                 ++weapon_cnt;
1612                         }
1613                 }
1614                 heapsort(weapon_cnt, weaponorder_swap, weaponorder_cmp, world);
1615         }
1616
1617         HUD_Panel_DrawBg(1);
1618         if(panel_bg_padding)
1619         {
1620                 panel_pos += '1 1 0' * panel_bg_padding;
1621                 panel_size -= '2 2 0' * panel_bg_padding;
1622         }
1623
1624         // hits
1625         weapon_stats = getstati(STAT_DAMAGE_HITS);
1626         weapon_number = weapon_stats & 63;
1627         weapon_hits[weapon_number-WEP_FIRST] = floor(weapon_stats / 64);
1628         // fired
1629         weapon_stats = getstati(STAT_DAMAGE_FIRED);
1630         weapon_number = weapon_stats & 63;
1631         weapon_fired[weapon_number-WEP_FIRST] = floor(weapon_stats / 64);
1632
1633         if(cvar_or("hud_panel_weapons_fade", 1))
1634         {
1635                 fade = 3.2 - 2 * (time - weapontime);
1636                 fade = bound(0.7, fade, 1);
1637         }
1638         else
1639                 fade = 1;
1640
1641         HUD_Weapons_Clear();
1642
1643         float rows, columns;
1644         rows = panel_size_y/panel_size_x;
1645         rows = bound(1, floor((sqrt(4 * autocvar_hud_panel_weapons_aspect * rows * WEP_COUNT + rows * rows) + rows + 0.5) / 2), WEP_COUNT);
1646
1647         columns = ceil(WEP_COUNT/rows);
1648         float row, column;
1649
1650         float a, type, fullammo;
1651         float when;
1652         when = autocvar_hud_panel_weapons_complainbubble_time;
1653         float fadetime;
1654         fadetime = autocvar_hud_panel_weapons_complainbubble_fadetime;
1655
1656         vector color;
1657         vector wpnpos;
1658         vector wpnsize;
1659
1660         float show_accuracy;
1661         if(autocvar_hud_panel_weapons_accuracy && acc_levels)
1662                 show_accuracy = true;
1663
1664         for(i = 0; i < weapon_cnt; ++i)
1665         {
1666                 wpnpos = panel_pos + eX * column * panel_size_x*(1/columns) + eY * row * panel_size_y*(1/rows);
1667                 wpnsize = eX * panel_size_x*(1/columns) + eY * panel_size_y*(1/rows);
1668
1669                 self = weaponorder[i];
1670                 weapid = self.impulse;
1671
1672                 // draw background behind currently selected weapon
1673                 if(self.weapon == activeweapon)
1674                         drawpic_aspect_skin(wpnpos, "weapon_current_bg", wpnsize, '1 1 1', fade * panel_fg_alpha, DRAWFLAG_NORMAL);
1675
1676                 // draw the weapon accuracy
1677                 if(show_accuracy)
1678                 {
1679                         float weapon_hit, weapon_damage;
1680                         weapon_damage = weapon_fired[self.weapon-WEP_FIRST];
1681                         if(weapon_damage)
1682                         {
1683                                 weapon_hit = weapon_hits[self.weapon-WEP_FIRST];
1684                                 weapon_stats = floor(100 * weapon_hit / weapon_damage);
1685                         }
1686
1687                         // find the max level lower than weapon_stats
1688                         float j;
1689                         j = acc_levels-1;
1690                         while ( j && weapon_stats < acc_lev[j] )
1691                                 --j;
1692
1693                         // inject color j+1 in color j, how much depending on how much weapon_stats is higher than level j
1694                         float factor;
1695                         factor = (weapon_stats - acc_lev[j]) / (acc_lev[j+1] - acc_lev[j]);
1696                         color = acc_color(j);
1697                         color = color + factor * (acc_color(j+1) - color);
1698
1699                         if(weapon_damage)
1700                                 drawpic_aspect_skin(wpnpos, "weapon_accuracy", wpnsize, color, panel_fg_alpha, DRAWFLAG_NORMAL);
1701                 }
1702
1703                 // draw the weapon icon
1704                 if((self.impulse >= 0) && (getstati(STAT_WEAPONS) & self.weapons))
1705                 {
1706                         drawpic_aspect_skin(wpnpos, strcat("weapon", self.netname), wpnsize, '1 1 1', fade * panel_fg_alpha, DRAWFLAG_NORMAL);
1707
1708                         if(autocvar_hud_panel_weapons_label == 1) // weapon number
1709                                 drawstring(wpnpos, ftos(weapid), '1 1 0' * 0.5 * panel_size_y*(1/rows), '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
1710                         else if(autocvar_hud_panel_weapons_label == 2) // bind
1711                                 drawstring(wpnpos, getcommandkey(ftos(weapid), strcat("impulse ", ftos(weapid))), '1 1 0' * 0.5 * panel_size_y*(1/rows), '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
1712
1713                         // draw ammo status bar
1714                         if(autocvar_hud_panel_weapons_ammo && weapid != WEP_TUBA && weapid != WEP_LASER && weapid != WEP_PORTO)
1715                         {
1716                                 a = 0;
1717                                 type = GetAmmoTypeForWep(weapid);
1718                                 if(type != -1)
1719                                         a = getstati(GetAmmoStat(type)); // how much ammo do we have?
1720
1721                                 if(a > 0)
1722                                 {
1723                                         switch(type) {
1724                                                 case 0: fullammo = autocvar_hud_panel_weapons_ammo_full_shells; break;
1725                                                 case 1: fullammo = autocvar_hud_panel_weapons_ammo_full_nails; break;
1726                                                 case 2: fullammo = autocvar_hud_panel_weapons_ammo_full_rockets; break;
1727                                                 case 3: fullammo = autocvar_hud_panel_weapons_ammo_full_cells; break;
1728                                                 case 4: fullammo = autocvar_hud_panel_weapons_ammo_full_fuel; break;
1729                                                 default: fullammo = 60;
1730                                         }
1731
1732                                         vector barsize;
1733                                         vector barpos;
1734                                         if(wpnsize_x/wpnsize_y > autocvar_hud_panel_weapons_aspect)
1735                                         {
1736                                                 barsize_x = autocvar_hud_panel_weapons_aspect * wpnsize_y;
1737                                                 barsize_y = wpnsize_y;
1738
1739                                                 barpos_x = wpnpos_x + (wpnsize_x - barsize_x) / 2;
1740                                                 barpos_y = wpnpos_y;
1741                                         }
1742                                         else
1743                                         {
1744                                                 barsize_y = 1/autocvar_hud_panel_weapons_aspect * wpnsize_x;
1745                                                 barsize_x = wpnsize_x;
1746
1747                                                 barpos_y = wpnpos_y + (wpnsize_y - barsize_y) / 2;
1748                                                 barpos_x = wpnpos_x;
1749                                         }
1750
1751                                         drawsetcliparea(
1752                                                 barpos_x,
1753                                                 barpos_y,
1754                                                 barsize_x * bound(0, a/fullammo, 1),
1755                                                 barsize_y);
1756                                         drawpic_aspect_skin(wpnpos, "weapon_ammo", wpnsize, autocvar_hud_panel_weapons_ammo_color, panel_fg_alpha * autocvar_hud_panel_weapons_ammo_alpha, DRAWFLAG_NORMAL);
1757                                         drawresetcliparea();
1758                                 }
1759                         }
1760                 }
1761
1762                 // draw a "ghost weapon icon" if you don't have the weapon
1763                 else
1764                 {
1765                         drawpic_aspect_skin(wpnpos, strcat("weapon", self.netname), wpnsize, '0 0 0', panel_fg_alpha * 0.5, DRAWFLAG_NORMAL);
1766                 }
1767
1768                 // draw the complain message
1769                 if(time - complain_weapon_time < when + fadetime && self.weapon == complain_weapon && autocvar_hud_panel_weapons_complainbubble)
1770                 {
1771                         if(fadetime)
1772                         {
1773                                 if(complain_weapon_time + when > time)
1774                                         a = 1;
1775                                 else
1776                                         a = bound(0, (complain_weapon_time + when + fadetime - time) / fadetime, 1);
1777                         }
1778                         else
1779                         {
1780                                 if(complain_weapon_time + when > time)
1781                                         a = 1;
1782                                 else
1783                                         a = 0;
1784                         }
1785
1786                         string s;
1787                         if(complain_weapon_type == 0) {
1788                                 s = "Out of ammo";
1789                                 color = autocvar_hud_panel_weapons_complainbubble_color_outofammo;
1790                         }
1791                         else if(complain_weapon_type == 1) {
1792                                 s = "Don't have";
1793                                 color = autocvar_hud_panel_weapons_complainbubble_color_donthave;
1794                         }
1795                         else {
1796                                 s = "Unavailable";
1797                                 color = autocvar_hud_panel_weapons_complainbubble_color_unavailable;
1798                         }
1799                         drawpic_aspect_skin(wpnpos + '1 1 0' * autocvar_hud_panel_weapons_complainbubble_padding, "weapon_complainbubble", wpnsize - '2 2 0' * autocvar_hud_panel_weapons_complainbubble_padding, color, a * panel_fg_alpha, DRAWFLAG_NORMAL);
1800                         drawstring_aspect(wpnpos + '1 1 0' * autocvar_hud_panel_weapons_complainbubble_padding, s, wpnsize - '2 2 0' * autocvar_hud_panel_weapons_complainbubble_padding, '1 1 1', panel_fg_alpha * a, DRAWFLAG_NORMAL);
1801                 }
1802
1803                 ++row;
1804                 if(row >= rows)
1805                 {
1806                         row = 0;
1807                         ++column;
1808                 }
1809         }
1810
1811 }
1812
1813 // Ammo (#1)
1814 //
1815 // TODO: macro
1816 float GetAmmoItemCode(float i)
1817 {
1818         switch(i)
1819         {
1820                 case 0: return IT_SHELLS;
1821                 case 1: return IT_NAILS;
1822                 case 2: return IT_ROCKETS;
1823                 case 3: return IT_CELLS;
1824                 case 4: return IT_FUEL;
1825                 default: return -1;
1826         }
1827 }
1828
1829 string GetAmmoPicture(float i)
1830 {
1831         switch(i)
1832         {
1833                 case 0: return "ammo_shells";
1834                 case 1: return "ammo_bullets";
1835                 case 2: return "ammo_rockets";
1836                 case 3: return "ammo_cells";
1837                 case 4: return "ammo_fuel";
1838                 default: return "";
1839         }
1840 }
1841
1842 void DrawAmmoItem(vector myPos, vector mySize, float itemcode, float currently_selected)
1843 {
1844         float a;
1845         a = getstati(GetAmmoStat(itemcode)); // how much ammo do we have of type itemcode?
1846         if(autocvar__hud_configure)
1847                 a = 100;
1848
1849         vector color;
1850         if(a < 10)
1851                 color = '0.7 0 0';
1852         else
1853                 color = '1 1 1';
1854
1855         float alpha;
1856         if(currently_selected)
1857                 alpha = 1;
1858         else
1859                 alpha = 0.7;
1860
1861         vector newSize, newPos;
1862         if(mySize_x/mySize_y > 3)
1863         {
1864                 newSize_x = 3 * mySize_y;
1865                 newSize_y = mySize_y;
1866
1867                 newPos_x = myPos_x + (mySize_x - newSize_x) / 2;
1868                 newPos_y = myPos_y;
1869         }
1870         else
1871         {
1872                 newSize_y = 1/3 * mySize_x;
1873                 newSize_x = mySize_x;
1874
1875                 newPos_y = myPos_y + (mySize_y - newSize_y) / 2;
1876                 newPos_x = myPos_x;
1877         }
1878
1879         vector picpos, numpos;
1880         if(autocvar_hud_panel_ammo_iconalign)
1881         {
1882                 numpos = newPos;
1883                 picpos = newPos + eX * 2 * newSize_y;
1884         }
1885         else
1886         {
1887                 numpos = newPos + eX * newSize_y;
1888                 picpos = newPos;
1889         }
1890
1891         if (currently_selected)
1892                 drawpic_aspect_skin(newPos, "ammo_current_bg", newSize, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
1893
1894         drawfont = hud_bigfont;
1895         if(a > 0)
1896                 drawstring_aspect(numpos, ftos(a), eX * (2/3) * newSize_x + eY * newSize_y, color, panel_fg_alpha * alpha, DRAWFLAG_NORMAL);
1897         else // "ghost" ammo count
1898                 drawstring_aspect(numpos, ftos(a), eX * (2/3) * newSize_x + eY * newSize_y, '0 0 0', panel_fg_alpha * alpha * 0.5, DRAWFLAG_NORMAL);
1899         drawfont = hud_font;
1900         if(a > 0)
1901                 drawpic_aspect_skin(picpos, GetAmmoPicture(itemcode), '1 1 0' * newSize_y, '1 1 1', panel_fg_alpha * alpha, DRAWFLAG_NORMAL);
1902         else // "ghost" ammo icon
1903                 drawpic_aspect_skin(picpos, GetAmmoPicture(itemcode), '1 1 0' * newSize_y, '0 0 0', panel_fg_alpha * alpha * 0.5, DRAWFLAG_NORMAL);
1904 }
1905
1906 void HUD_Ammo(void)
1907 {
1908         if(!autocvar_hud_panel_ammo && !autocvar__hud_configure)
1909                 return;
1910
1911         active_panel = HUD_PANEL_AMMO;
1912         HUD_Panel_UpdateCvars(ammo);
1913         float i, currently_selected;
1914
1915         vector pos, mySize;
1916         pos = panel_pos;
1917         mySize = panel_size;
1918
1919         HUD_Panel_DrawBg(1);
1920         if(panel_bg_padding)
1921         {
1922                 pos += '1 1 0' * panel_bg_padding;
1923                 mySize -= '2 2 0' * panel_bg_padding;
1924         }
1925
1926         float rows, columns;
1927         rows = mySize_y/mySize_x;
1928         rows = bound(1, floor((sqrt(4 * (3/1) * rows * AMMO_COUNT + rows * rows) + rows + 0.5) / 2), AMMO_COUNT);
1929         //                               ^^^ ammo item aspect goes here
1930
1931         columns = ceil(AMMO_COUNT/rows);
1932
1933         float row, column;
1934         // ammo
1935         for (i = 0; i < AMMO_COUNT; ++i) {
1936                 currently_selected = getstati(STAT_ITEMS) & GetAmmoItemCode(i);
1937                 if(autocvar_hud_panel_ammo_onlycurrent) {
1938                         if(autocvar__hud_configure)
1939                                 i = 2;
1940                         if (currently_selected || autocvar__hud_configure)
1941                         {
1942                                 DrawAmmoItem(pos, mySize, i, currently_selected);
1943                                 break;
1944                         }
1945                 } else {
1946                         DrawAmmoItem(pos + eX * column * mySize_x*(1/columns) + eY * row * mySize_y*(1/rows), eX * mySize_x*(1/columns) + eY * mySize_y*(1/rows), i, currently_selected);
1947                         ++row;
1948                         if(row >= rows)
1949                         {
1950                                 row = 0;
1951                                 column = column + 1;
1952                         }
1953                 }
1954         }
1955 }
1956
1957 void DrawNumIcon(float iconalign, vector myPos, vector mySize, float x, string icon, float left, vector color, float alpha)
1958 {
1959         vector newSize, newPos;
1960         if(mySize_x/mySize_y > 3)
1961         {
1962                 newSize_x = 3 * mySize_y;
1963                 newSize_y = mySize_y;
1964
1965                 newPos_x = myPos_x + (mySize_x - newSize_x) / 2;
1966                 newPos_y = myPos_y;
1967         }
1968         else
1969         {
1970                 newSize_y = 1/3 * mySize_x;
1971                 newSize_x = mySize_x;
1972
1973                 newPos_y = myPos_y + (mySize_y - newSize_y) / 2;
1974                 newPos_x = myPos_x;
1975         }
1976
1977         vector picpos, numpos;
1978         if(left)
1979         {
1980                 if(iconalign == 1 || iconalign == 3) // right align
1981                 {
1982                         numpos = newPos;
1983                         picpos = newPos + eX * 2 * newSize_y;
1984                 }
1985                 else // left align
1986                 {
1987                         numpos = newPos + eX * newSize_y;
1988                         picpos = newPos;
1989                 }
1990         }
1991         else
1992         {
1993                 if(iconalign == 0 || iconalign == 3) // left align
1994                 {
1995                         numpos = newPos + eX * newSize_y;
1996                         picpos = newPos;
1997                 } 
1998                 else // right align
1999                 {
2000                         numpos = newPos;
2001                         picpos = newPos + eX * 2 * newSize_y;
2002                 }
2003         }
2004
2005         drawfont = hud_bigfont;
2006         drawstring_aspect(numpos, ftos(x), eX * (2/3) * newSize_x + eY * newSize_y, color, panel_fg_alpha * alpha, DRAWFLAG_NORMAL);
2007         drawfont = hud_font;
2008         drawpic_aspect_skin(picpos, icon, '1 1 0' * newSize_y, '1 1 1', panel_fg_alpha * alpha, DRAWFLAG_NORMAL);
2009 }
2010
2011 void DrawNumIcon_expanding(float iconalign, vector myPos, vector mySize, float x, string icon, float left, vector color, float fadelerp)
2012 {
2013         float sz;
2014         sz = expandingbox_sizefactor_from_fadelerp(fadelerp);
2015
2016         DrawNumIcon(iconalign, myPos + expandingbox_resize_centered_box_offset(sz, mySize, 1), mySize * sz, x, icon, left, color, (1 - fadelerp));
2017 }
2018
2019 // Powerups (#2)
2020 //
2021 void HUD_Powerups(void) {
2022         if(!autocvar_hud_panel_powerups && !autocvar__hud_configure)
2023                 return;
2024
2025         active_panel = HUD_PANEL_POWERUPS;
2026         HUD_Panel_UpdateCvars(powerups);
2027         float stat_items;
2028         stat_items = getstati(STAT_ITEMS);
2029
2030         if(!autocvar__hud_configure)
2031         {
2032                 if not(stat_items & IT_STRENGTH)
2033                         if not(stat_items & IT_INVINCIBLE)
2034                                 return;
2035
2036                 if (getstati(STAT_HEALTH) <= 0)
2037                         return;
2038         }
2039
2040         vector pos, mySize;
2041         pos = panel_pos;
2042         mySize = panel_size;
2043
2044         float strength_time, shield_time;
2045         if(autocvar__hud_configure)
2046         {
2047                 strength_time = 15;
2048                 shield_time = 27;
2049         }
2050         else
2051         {
2052                 strength_time = bound(0, getstatf(STAT_STRENGTH_FINISHED) - time, 99);
2053                 shield_time = bound(0, getstatf(STAT_INVINCIBLE_FINISHED) - time, 99);
2054         }
2055
2056         HUD_Panel_DrawBg(bound(0, max(strength_time, shield_time), 1));
2057         if(panel_bg_padding)
2058         {
2059                 pos += '1 1 0' * panel_bg_padding;
2060                 mySize -= '2 2 0' * panel_bg_padding;
2061         }
2062
2063         vector barpos, barsize;
2064         vector picpos;
2065         vector numpos;
2066
2067         string leftname, rightname;
2068         float leftcnt, rightcnt;
2069         float leftexact, rightexact;
2070         if (autocvar_hud_panel_powerups_flip) {
2071                 leftname = "strength";
2072                 leftcnt = ceil(strength_time);
2073                 leftexact = strength_time;
2074
2075                 rightname = "shield";
2076                 rightcnt = ceil(shield_time);
2077                 rightexact = shield_time;
2078         } else {
2079                 leftname = "shield";
2080                 leftcnt = ceil(shield_time);
2081                 leftexact = shield_time;
2082
2083                 rightname = "strength";
2084                 rightcnt = ceil(strength_time);
2085                 rightexact = strength_time;
2086         }
2087
2088         drawfont = hud_bigfont;
2089         if (mySize_x/mySize_y > 4)
2090         {
2091                 if(leftcnt)
2092                 {
2093                         if(autocvar_hud_panel_powerups_baralign == 1 || autocvar_hud_panel_powerups_baralign == 3) { // right align
2094                                 barpos = pos + eX * 0.5 * mySize_x - eX * 0.5 * mySize_x * min(1, leftcnt/30);
2095                                 barsize = eX * 0.5 * mySize_x * min(1, leftcnt/30) + eY * mySize_y;
2096                         } else { // left align
2097                                 barpos = pos;
2098                                 barsize = eX * 0.5 * mySize_x * min(1, leftcnt/30) + eY * mySize_y;
2099                         }
2100
2101                         if(autocvar_hud_panel_powerups_progressbar)
2102                         {
2103                                 HUD_Panel_GetProgressBarColor(leftname)
2104                                 HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha * bound(0, max(strength_time, shield_time), 1), DRAWFLAG_NORMAL);
2105                         }
2106                         if(leftcnt > 1)
2107                                 DrawNumIcon(autocvar_hud_panel_powerups_iconalign, pos, eX * 0.5 * mySize_x + eY * mySize_y, leftcnt, leftname, 1, '1 1 1', 1);
2108                         if(leftcnt <= 5)
2109                                 DrawNumIcon_expanding(autocvar_hud_panel_powerups_iconalign, pos, eX * 0.5 * mySize_x + eY * mySize_y, leftcnt, leftname, 1, '1 1 1', bound(0, (leftcnt - leftexact) / 0.5, 1));
2110                 }
2111
2112                 if(rightcnt)
2113                 {
2114                         if(autocvar_hud_panel_powerups_baralign == 0 || autocvar_hud_panel_powerups_baralign == 3) { // left align
2115                                 barpos = pos + eX * 0.5 * mySize_x;
2116                                 barsize = eX * 0.5 * mySize_x * min(1, rightcnt/30) + eY * mySize_y;
2117                         } else { // right align
2118                                 barpos = pos + eX * mySize_x - eX * 0.5 * mySize_x * min(1, rightcnt/30);
2119                                 barsize = eX * 0.5 * mySize_x * min(1, rightcnt/30) + eY * mySize_y;
2120                         }
2121
2122                         if(autocvar_hud_panel_powerups_progressbar)
2123                         {
2124                                 HUD_Panel_GetProgressBarColor(rightname)
2125                                 HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha * bound(0, max(strength_time, shield_time), 1) * panel_fg_alpha, DRAWFLAG_NORMAL);
2126                         }
2127                         if(rightcnt > 1)
2128                                 DrawNumIcon(autocvar_hud_panel_powerups_iconalign, pos + eX * 0.5 * mySize_x, eX * 0.5 * mySize_x + eY * mySize_y, rightcnt, rightname, 0, '1 1 1', 1);
2129                         if(rightcnt <= 5)
2130                                 DrawNumIcon_expanding(autocvar_hud_panel_powerups_iconalign, pos + eX * 0.5 * mySize_x, eX * 0.5 * mySize_x + eY * mySize_y, rightcnt, rightname, 0, '1 1 1', bound(0, (rightcnt - rightexact) / 0.5, 1));
2131                 }
2132         }
2133         else if (mySize_x/mySize_y > 1.5)
2134         {
2135                 if(leftcnt)
2136                 {
2137                         if(autocvar_hud_panel_powerups_baralign == 1 || autocvar_hud_panel_powerups_baralign == 3) { // right align
2138                                 barpos = pos + eX * mySize_x - eX * mySize_x * min(1, leftcnt/30);
2139                                 barsize = eX * mySize_x * min(1, leftcnt/30) + eY * 0.5 * mySize_y;
2140                         } else { // left align
2141                                 barpos = pos;
2142                                 barsize = eX * mySize_x * min(1, leftcnt/30) + eY * 0.5 * mySize_y;
2143                         }
2144
2145                         if(autocvar_hud_panel_powerups_progressbar)
2146                         {
2147                                 HUD_Panel_GetProgressBarColor(leftname)
2148                                 HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha * bound(0, max(strength_time, shield_time), 1) * panel_fg_alpha, DRAWFLAG_NORMAL);
2149                         }
2150                         if(leftcnt > 1)
2151                                 DrawNumIcon(autocvar_hud_panel_powerups_iconalign, pos, eX * mySize_x + eY * 0.5 * mySize_y, leftcnt, leftname, 1, '1 1 1', 1);
2152                         if(leftcnt <= 5)
2153                                 DrawNumIcon_expanding(autocvar_hud_panel_powerups_iconalign, pos, eX * mySize_x + eY * 0.5 * mySize_y, leftcnt, leftname, 1, '1 1 1', bound(0, (leftcnt - leftexact) / 0.5, 1));
2154                 }
2155
2156                 if(rightcnt)
2157                 {
2158                         if(autocvar_hud_panel_powerups_baralign == 0 || autocvar_hud_panel_powerups_baralign == 3) { // left align
2159                                 barpos = pos + eY * 0.5 * mySize_y;
2160                                 barsize = eX * mySize_x * min(1, rightcnt/30) + eY * 0.5 * mySize_y;
2161                         } else { // right align
2162                                 barpos = pos + eX * mySize_x - eX * mySize_x * min(1, rightcnt/30) + eY * 0.5 * mySize_y;
2163                                 barsize = eX * mySize_x * min(1, rightcnt/30) + eY * 0.5 * mySize_y;
2164                         }
2165
2166                         if(autocvar_hud_panel_powerups_progressbar)
2167                         {
2168                                 HUD_Panel_GetProgressBarColor(rightname)
2169                                 HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha * bound(0, max(strength_time, shield_time), 1) * panel_fg_alpha, DRAWFLAG_NORMAL);
2170                         }
2171                         if(rightcnt > 1)
2172                                 DrawNumIcon(autocvar_hud_panel_powerups_iconalign, pos + eY * 0.5 * mySize_y, eX * mySize_x + eY * 0.5 * mySize_y, rightcnt, rightname, 0, '1 1 1', 1);
2173                         if(rightcnt <= 5)
2174                                 DrawNumIcon_expanding(autocvar_hud_panel_powerups_iconalign, pos + eY * 0.5 * mySize_y, eX * mySize_x + eY * 0.5 * mySize_y, rightcnt, rightname, 0, '1 1 1', bound(0, (rightcnt - rightexact) / 0.5, 1));
2175                 }
2176         }
2177         else
2178         {
2179                 if(leftcnt)
2180                 {
2181                         if(autocvar_hud_panel_powerups_baralign == 1 || autocvar_hud_panel_powerups_baralign == 3) { // down align
2182                                 barpos = pos + eY * mySize_y - eY * mySize_y * min(1, leftcnt/30);
2183                                 barsize = eX * 0.5 * mySize_x + eY * mySize_y * min(1, leftcnt/30);
2184                         } else { // up align
2185                                 barpos = pos;
2186                                 barsize = eX * 0.5 * mySize_x + eY * mySize_y * min(1, leftcnt/30);
2187                         }
2188
2189                         if(autocvar_hud_panel_powerups_iconalign == 1 || autocvar_hud_panel_powerups_iconalign == 3) { // down align
2190                                 picpos = pos + eX * 0.05 * mySize_x + eY * (mySize_y - 0.65 * mySize_x);
2191                                 numpos = pos + eY * mySize_y - eY * 0.25 * mySize_x;
2192                         } else { // up align
2193                                 picpos = pos + eX * 0.05 * mySize_x;
2194                                 numpos = pos + eY * 0.4 * mySize_x;
2195                         }
2196
2197                         if(autocvar_hud_panel_powerups_progressbar)
2198                         {
2199                                 HUD_Panel_GetProgressBarColor(leftname)
2200                                 HUD_Panel_DrawProgressBar(barpos, 1, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha * bound(0, max(strength_time, shield_time), 1) * panel_fg_alpha, DRAWFLAG_NORMAL);
2201                         }
2202                         if(leftcnt <= 5)
2203                                 drawpic_aspect_skin_expanding(picpos, leftname, '0.4 0.4 0' * mySize_x, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL, bound(0, (leftcnt - leftexact) / 0.5, 1));
2204                         if(leftcnt > 1)
2205                                 drawpic_aspect_skin(picpos, leftname, '0.4 0.4 0' * mySize_x, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2206                         drawstring_aspect(numpos, ftos(leftcnt), eX * 0.5 * mySize_x + eY * 0.25 * mySize_x, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2207                 }
2208
2209                 if(rightcnt)
2210                 {
2211                         if(autocvar_hud_panel_powerups_baralign == 0 || autocvar_hud_panel_powerups_baralign == 3) { // up align
2212                                 barpos = pos + eX * 0.5 * mySize_x;
2213                                 barsize = eX * 0.5 * mySize_x + eY * mySize_y * min(1, rightcnt/30);
2214                         } else { // down align
2215                                 barpos = pos + eY * mySize_y - eY * mySize_y * min(1, rightcnt/30) + eX * 0.5 * mySize_x;
2216                                 barsize = eX * 0.5 * mySize_x + eY * mySize_y * min(1, rightcnt/30);
2217                         }
2218
2219                         if(autocvar_hud_panel_powerups_iconalign == 0 || autocvar_hud_panel_powerups_iconalign == 3) { // up align
2220                                 picpos = pos + eX * 0.05 * mySize_x + eX * 0.5 * mySize_x;
2221                                 numpos = pos + eY * 0.4 * mySize_x + eX * 0.5 * mySize_x;
2222                         } else { // down align
2223                                 picpos = pos + eX * 0.05 * mySize_x + eY * (mySize_y - 0.65 * mySize_x) + eX * 0.5 * mySize_x;
2224                                 numpos = pos + eY * mySize_y - eY * 0.25 * mySize_x + eX * 0.5 * mySize_x;
2225                         }
2226
2227                         if(autocvar_hud_panel_powerups_progressbar)
2228                         {
2229                                 HUD_Panel_GetProgressBarColor(rightname)
2230                                 HUD_Panel_DrawProgressBar(barpos, 1, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha * bound(0, max(strength_time, shield_time), 1) * panel_fg_alpha, DRAWFLAG_NORMAL);
2231                         }
2232                         if(rightcnt <= 5)
2233                                 drawpic_aspect_skin_expanding(picpos, rightname, '0.4 0.4 0' * mySize_x, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL, bound(0, (rightcnt - rightexact) / 0.5, 1));
2234                         if(rightcnt > 1)
2235                                 drawpic_aspect_skin(picpos, rightname, '0.4 0.4 0' * mySize_x, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2236                         drawstring_aspect(numpos, ftos(rightcnt), eX * 0.5 * mySize_x + eY * 0.25 * mySize_x, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
2237                 }
2238         }
2239         drawfont = hud_font;
2240 }
2241
2242 // Health/armor (#3)
2243 //
2244 void HUD_HealthArmor(void)
2245 {
2246         if(!autocvar_hud_panel_healtharmor && !autocvar__hud_configure)
2247                 return;
2248
2249         active_panel = HUD_PANEL_HEALTHARMOR;
2250         HUD_Panel_UpdateCvars(healtharmor);
2251         vector pos, mySize;
2252         pos = panel_pos;
2253         mySize = panel_size;
2254
2255         HUD_Panel_DrawBg(1);
2256         if(panel_bg_padding)
2257         {
2258                 pos += '1 1 0' * panel_bg_padding;
2259                 mySize -= '2 2 0' * panel_bg_padding;
2260         }
2261
2262         float armor, health, fuel;
2263         armor = getstati(STAT_ARMOR);
2264         health = getstati(STAT_HEALTH);
2265         fuel = getstati(STAT_FUEL);
2266
2267         if(autocvar__hud_configure)
2268         {
2269                 armor = 150;
2270                 health = 100;
2271                 fuel = 70;
2272         }
2273
2274         if(health <= 0)
2275                 return;
2276
2277         vector barpos, barsize;
2278         vector picpos;
2279         vector numpos;
2280
2281         drawfont = hud_bigfont;
2282         if(autocvar_hud_panel_healtharmor == 2) // combined health and armor display
2283         {
2284                 vector v;
2285                 v = healtharmor_maxdamage(health, armor, armorblockpercent);
2286
2287                 float x;
2288                 x = floor(v_x + 1);
2289
2290                 if(autocvar_hud_panel_healtharmor_baralign == 1 || autocvar_hud_panel_healtharmor_baralign == 3) { // right align
2291                         barpos = pos + eX * mySize_x - eX * mySize_x * min(1, x/400);
2292                         barsize = eX * mySize_x * min(1, x/400) + eY * mySize_y;
2293                 } else { // left align
2294                         barpos = pos;
2295                         barsize = eX * mySize_x * min(1, x/400) + eY * mySize_y;
2296                 }
2297
2298                 string biggercount;
2299                 if(v_z) // NOT fully armored
2300                 {
2301                         biggercount = "health";
2302                         if(autocvar_hud_panel_healtharmor_progressbar)
2303                         {
2304                                 HUD_Panel_GetProgressBarColor("health")
2305                                 HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2306                         }
2307                         if(armor)
2308                                 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);
2309                 }
2310                 else
2311                 {
2312                         biggercount = "armor";
2313                         if(autocvar_hud_panel_healtharmor_progressbar)
2314                         {
2315                                 HUD_Panel_GetProgressBarColor("armor")
2316                                 HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2317                         }
2318                         if(health)
2319                                 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);
2320                 }
2321                 DrawNumIcon(autocvar_hud_panel_healtharmor_iconalign, pos, mySize, x, biggercount, 1, HUD_Get_Num_Color(x, 2 * 200), 1);
2322
2323                 // fuel
2324                 if(fuel)
2325                 {
2326                         if(autocvar_hud_panel_healtharmor_baralign == 0 || autocvar_hud_panel_healtharmor_baralign == 3) { // left align
2327                                 barpos = pos + eX * mySize_x - eX * mySize_x * min(1, fuel/100);
2328                                 barsize = eX * mySize_x * min(1, fuel/100) + eY * 0.2 * mySize_y;
2329                         } else {
2330                                 barpos = pos;
2331                                 barsize = eX * mySize_x * min(1, fuel/100) + eY * 0.2 * mySize_y;
2332                         }
2333                         HUD_Panel_GetProgressBarColor("fuel")
2334                         HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, panel_fg_alpha * 0.8, DRAWFLAG_NORMAL);
2335                 }
2336         }
2337         else
2338         {
2339                 string leftname, rightname;
2340                 float leftcnt, rightcnt;
2341                 float leftactive, rightactive;
2342                 float leftalpha, rightalpha;
2343                 if (autocvar_hud_panel_healtharmor_flip) { // old style layout with armor left/top of health
2344                         leftname = "armor";
2345                         leftcnt = armor;
2346                         if(leftcnt)
2347                                 leftactive = 1;
2348                         leftalpha = min((armor+10)/55, 1);
2349
2350                         rightname = "health";
2351                         rightcnt = health;
2352                         rightactive = 1;
2353                         rightalpha = 1;
2354                 } else {
2355                         leftname = "health";
2356                         leftcnt = health;
2357                         leftactive = 1;
2358                         leftalpha = 1;
2359
2360                         rightname = "armor";
2361                         rightcnt = armor;
2362                         if(rightcnt)
2363                                 rightactive = 1;
2364                         rightalpha = min((armor+10)/55, 1);
2365                 }
2366
2367                 if (mySize_x/mySize_y > 4)
2368                 {
2369                         if(leftactive)
2370                         {
2371                                 if(autocvar_hud_panel_healtharmor_baralign == 1 || autocvar_hud_panel_healtharmor_baralign == 3) { // right align
2372                                         barpos = pos + eX * 0.5 * mySize_x - eX * 0.5 * mySize_x * min(1, leftcnt/200);
2373                                         barsize = eX * 0.5 * mySize_x * min(1, leftcnt/200) + eY * mySize_y;
2374                                 } else { // left align
2375                                         barpos = pos;
2376                                         barsize = eX * 0.5 * mySize_x * min(1, leftcnt/200) + eY * mySize_y;
2377                                 }
2378
2379                                 if(autocvar_hud_panel_healtharmor_progressbar)
2380                                 {
2381                                         HUD_Panel_GetProgressBarColor(leftname)
2382                                         HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2383                                 }
2384                                 DrawNumIcon(autocvar_hud_panel_healtharmor_iconalign, pos, eX * 0.5 * mySize_x + eY * mySize_y, leftcnt, leftname, 1, HUD_Get_Num_Color(leftcnt, 200), 1);
2385                         }
2386
2387                         if(rightactive)
2388                         {
2389                                 if(autocvar_hud_panel_healtharmor_baralign == 0 || autocvar_hud_panel_healtharmor_baralign == 3) { // left align
2390                                         barpos = pos + eX * 0.5 * mySize_x;
2391                                         barsize = eX * 0.5 * mySize_x * min(1, rightcnt/200) + eY * mySize_y;
2392                                 } else { // right align
2393                                         barpos = pos + eX * mySize_x - eX * 0.5 * mySize_x * min(1, rightcnt/200);
2394                                         barsize = eX * 0.5 * mySize_x * min(1, rightcnt/200) + eY * mySize_y;
2395                                 }
2396
2397                                 if(autocvar_hud_panel_healtharmor_progressbar)
2398                                 {
2399                                         HUD_Panel_GetProgressBarColor(rightname)
2400                                         HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2401                                 }
2402                                 DrawNumIcon(autocvar_hud_panel_healtharmor_iconalign, pos + eX * 0.5 * mySize_x, eX * 0.5 * mySize_x + eY * mySize_y, rightcnt, rightname, 0, HUD_Get_Num_Color(rightcnt, 200), 1);
2403                         }
2404
2405                         if(fuel)
2406                         {
2407                                 if(autocvar_hud_panel_healtharmor_baralign == 0 || autocvar_hud_panel_healtharmor_baralign == 3) { // left align
2408                                         barpos = pos + eX * mySize_x - eX * mySize_x * min(1, fuel/100);
2409                                         barsize = eX * mySize_x * min(1, fuel/100) + eY * 0.2 * mySize_y;
2410                                 } else {
2411                                         barpos = pos;
2412                                         barsize = eX * mySize_x * min(1, fuel/100) + eY * 0.2 * mySize_y;
2413                                 }
2414                                 HUD_Panel_GetProgressBarColor("fuel")
2415                                 HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, panel_fg_alpha * 0.8, DRAWFLAG_NORMAL);
2416                         }
2417                 }
2418                 else if (mySize_x/mySize_y > 1.5)
2419                 {
2420                         if(leftactive)
2421                         {
2422                                 if(autocvar_hud_panel_healtharmor_baralign == 1 || autocvar_hud_panel_healtharmor_baralign == 3) { // right align
2423                                         barpos = pos + eX * mySize_x - eX * mySize_x * min(1, leftcnt/200);
2424                                         barsize = eX * mySize_x * min(1, leftcnt/200) + eY * 0.5 * mySize_y;
2425                                 } else { // left align
2426                                         barpos = pos;
2427                                         barsize = eX * mySize_x * min(1, leftcnt/200) + eY * 0.5 * mySize_y;
2428                                 }
2429
2430                                 if(autocvar_hud_panel_healtharmor_progressbar)
2431                                 {
2432                                         HUD_Panel_GetProgressBarColor(leftname)
2433                                         HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2434                                 }
2435                                 DrawNumIcon(autocvar_hud_panel_healtharmor_iconalign, pos, eX * mySize_x + eY * 0.5 * mySize_y, leftcnt, leftname, 1, HUD_Get_Num_Color(leftcnt, 200), 1);
2436                         }
2437
2438                         if(rightactive)
2439                         {
2440                                 if(autocvar_hud_panel_healtharmor_baralign == 0 || autocvar_hud_panel_healtharmor_baralign == 3) { // left align
2441                                         barpos = pos + eY * 0.5 * mySize_y;
2442                                         barsize = eX * mySize_x * min(1, rightcnt/200) + eY * 0.5 * mySize_y;
2443                                 } else { // right align
2444                                         barpos = pos + eX * mySize_x - eX * mySize_x * min(1, rightcnt/200) + eY * 0.5 * mySize_y;
2445                                         barsize = eX * mySize_x * min(1, rightcnt/200) + eY * 0.5 * mySize_y;
2446                                 }
2447
2448                                 if(autocvar_hud_panel_healtharmor_progressbar)
2449                                 {
2450                                         HUD_Panel_GetProgressBarColor(rightname)
2451                                         HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2452                                 }
2453                                 DrawNumIcon(autocvar_hud_panel_healtharmor_iconalign, pos + eY * 0.5 * mySize_y, eX * mySize_x + eY * 0.5 * mySize_y, rightcnt, rightname, 0, HUD_Get_Num_Color(rightcnt, 200), 1);
2454                         }
2455
2456                         if(fuel)
2457                         {
2458                                 if(autocvar_hud_panel_healtharmor_baralign == 0 || autocvar_hud_panel_healtharmor_baralign == 3) { // left align
2459                                         barpos = pos + eX * mySize_x - eX * mySize_x * min(1, fuel/100);
2460                                         barsize = eX * mySize_x * min(1, fuel/100) + eY * 0.1 * mySize_y;
2461                                 } else {
2462                                         barpos = pos;
2463                                         barsize = eX * mySize_x * min(1, fuel/100) + eY * 0.1 * mySize_y;
2464                                 }
2465                                 HUD_Panel_GetProgressBarColor("fuel")
2466                                 HUD_Panel_DrawProgressBar(barpos, 0, barsize, progressbar_color, panel_fg_alpha * 0.8, DRAWFLAG_NORMAL);
2467                         }
2468                 }
2469                 else
2470                 {
2471                         if(leftactive)
2472                         {
2473                                 if(autocvar_hud_panel_healtharmor_baralign == 1 || autocvar_hud_panel_healtharmor_baralign == 3) { // down align
2474                                         barpos = pos + eY * mySize_y - eY * mySize_y * min(1, leftcnt/200);
2475                                         barsize = eX * 0.5 * mySize_x + eY * mySize_y * min(1, leftcnt/200);
2476                                 } else { // up align
2477                                         barpos = pos;
2478                                         barsize = eX * 0.5 * mySize_x + eY * mySize_y * min(1, leftcnt/200);
2479                                 }
2480
2481                                 if(autocvar_hud_panel_healtharmor_iconalign == 1 || autocvar_hud_panel_healtharmor_iconalign == 3) { // down align
2482                                         picpos = pos + eX * 0.05 * mySize_x + eY * (mySize_y - 0.65 * mySize_x);
2483                                         numpos = pos + eY * mySize_y - eY * 0.25 * mySize_x;
2484                                 } else { // up align
2485                                         picpos = pos + eX * 0.05 * mySize_x;
2486                                         numpos = pos + eY * 0.4 * mySize_x;
2487                                 }
2488
2489                                 if(autocvar_hud_panel_healtharmor_progressbar)
2490                                 {
2491                                         HUD_Panel_GetProgressBarColor(leftname)
2492                                         HUD_Panel_DrawProgressBar(barpos, 1, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2493                                 }
2494                                 drawpic_aspect_skin(picpos, leftname, '0.4 0.4 0' * mySize_x, '1 1 1', leftalpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2495                                 drawstring_aspect(numpos, ftos(leftcnt), eX * 0.5 * mySize_x + eY * 0.25 * mySize_x, HUD_Get_Num_Color(leftcnt, 200), panel_fg_alpha, DRAWFLAG_NORMAL);
2496                         }
2497
2498                         if(rightactive)
2499                         {
2500                                 if(autocvar_hud_panel_healtharmor_baralign == 0 || autocvar_hud_panel_healtharmor_baralign == 3) { // up align
2501                                         barpos = pos + eX * 0.5 * mySize_x;
2502                                         barsize = eX * 0.5 * mySize_x + eY * mySize_y * min(1, rightcnt/200);
2503                                 } else { // down align
2504                                         barpos = pos + eY * mySize_y - eY * mySize_y * min(1, rightcnt/200) + eX * 0.5 * mySize_x;
2505                                         barsize = eX * 0.5 * mySize_x + eY * mySize_y * min(1, rightcnt/200);
2506                                 }
2507
2508                                 if(autocvar_hud_panel_healtharmor_iconalign == 0 || autocvar_hud_panel_healtharmor_iconalign == 3) { // up align
2509                                         picpos = pos + eX * 0.05 * mySize_x + eX * 0.5 * mySize_x;
2510                                         numpos = pos + eY * 0.4 * mySize_x + eX * 0.5 * mySize_x;
2511                                 } else { // down align
2512                                         picpos = pos + eX * 0.05 * mySize_x + eY * (mySize_y - 0.65 * mySize_x) + eX * 0.5 * mySize_x;
2513                                         numpos = pos + eY * mySize_y - eY * 0.25 * mySize_x + eX * 0.5 * mySize_x;
2514                                 }
2515
2516                                 if(autocvar_hud_panel_healtharmor_progressbar)
2517                                 {
2518                                         HUD_Panel_GetProgressBarColor(rightname)
2519                                         HUD_Panel_DrawProgressBar(barpos, 1, barsize, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2520                                 }
2521                                 drawpic_aspect_skin(picpos, rightname, '0.4 0.4 0' * mySize_x, '1 1 1', rightalpha * panel_fg_alpha, DRAWFLAG_NORMAL);
2522                                 drawstring_aspect(numpos, ftos(rightcnt), eX * 0.5 * mySize_x + eY * 0.25 * mySize_x, HUD_Get_Num_Color(rightcnt, 200), panel_fg_alpha, DRAWFLAG_NORMAL);
2523                         }
2524
2525                         if(fuel)
2526                         {
2527                                 if(autocvar_hud_panel_healtharmor_baralign == 0 || autocvar_hud_panel_healtharmor_baralign == 3) { // left align
2528                                         barpos = pos;
2529                                         barsize = eX * 0.05 * mySize_x + eY * mySize_y * min(1, fuel/100);
2530                                 } else {
2531                                         barpos = pos + eY * mySize_y - eY * mySize_y * min(1, fuel/100);
2532                                         barsize = eX * 0.05 * mySize_x + eY * mySize_y * min(1, fuel/100);
2533                                 }
2534                                 HUD_Panel_GetProgressBarColor("fuel")
2535                                 HUD_Panel_DrawProgressBar(barpos, 1, barsize, progressbar_color, panel_fg_alpha * 0.8, DRAWFLAG_NORMAL);
2536                         }
2537                 }
2538         }
2539         drawfont = hud_font;
2540 }
2541
2542 // Notification area (#4)
2543 //
2544
2545 string Weapon_SuicideMessage(float deathtype)
2546 {
2547         w_deathtype = deathtype;
2548         get_weaponinfo(DEATH_WEAPONOF(deathtype)).weapon_func(WR_SUICIDEMESSAGE);
2549         return w_deathtypestring;
2550 }
2551
2552 string Weapon_KillMessage(float deathtype)
2553 {
2554         w_deathtype = deathtype;
2555         get_weaponinfo(DEATH_WEAPONOF(deathtype)).weapon_func(WR_KILLMESSAGE);
2556         return w_deathtypestring;
2557 }
2558
2559 float killnotify_times[10];
2560 float killnotify_deathtype[10];
2561 float killnotify_actiontype[10]; // 0 = "Y [used by] X", 1 = "X [did action to] Y"
2562 string killnotify_attackers[10];
2563 string killnotify_victims[10];
2564 void HUD_KillNotify_Push(string attacker, string victim, float actiontype, float wpn)
2565 {
2566         float i;
2567         for (i = 9; i > 0; --i) {
2568                 killnotify_times[i] = killnotify_times[i-1];
2569                 killnotify_deathtype[i] = killnotify_deathtype[i-1];
2570                 killnotify_actiontype[i] = killnotify_actiontype[i-1];
2571                 if(killnotify_attackers[i])
2572                         strunzone(killnotify_attackers[i]);
2573                 killnotify_attackers[i] = strzone(killnotify_attackers[i-1]);
2574                 if(killnotify_victims[i])
2575                         strunzone(killnotify_victims[i]);
2576                 killnotify_victims[i] = strzone(killnotify_victims[i-1]);
2577         }
2578         killnotify_times[0] = time;
2579         killnotify_deathtype[0] = wpn;
2580         killnotify_actiontype[0] = actiontype;
2581         if(killnotify_attackers[0])
2582                 strunzone(killnotify_attackers[0]);
2583         killnotify_attackers[0] = strzone(attacker);
2584         if(killnotify_victims[0])
2585                 strunzone(killnotify_victims[0]);
2586         killnotify_victims[0] = strzone(victim);
2587 }
2588
2589 void HUD_KillNotify(string s1, string s2, string s3, float type, float msg) // s1 = attacker, s2 = victim
2590 {
2591         float w;
2592         float alsoprint, gentle;
2593         alsoprint = (autocvar_hud_panel_notify_print || !panel_enabled); // print message to console if: notify panel disabled, or cvar to do so enabled
2594         gentle = (autocvar_cl_gentle || autocvar_cl_gentle_messages);
2595         
2596         if(msg == MSG_SUICIDE) {
2597                 w = DEATH_WEAPONOF(type);
2598                 if(WEP_VALID(w)) {
2599                         HUD_KillNotify_Push(s1, "", 0, DEATH_GENERIC);
2600                         if (alsoprint)
2601                                 print("^1", sprintf(Weapon_SuicideMessage(type), strcat(s1, "^1")), "\n");
2602                 } else if (type == DEATH_KILL) {
2603                         HUD_KillNotify_Push(s1, "", 0, DEATH_KILL);
2604                         if (alsoprint)
2605                                 print ("^1",s1, "^1 couldn't take it anymore\n");
2606                 } else if (type == DEATH_ROT) {
2607                         HUD_KillNotify_Push(s1, "", 0, DEATH_GENERIC);
2608                         if (alsoprint)
2609                                 print ("^1",s1, "^1 died\n");
2610                 } else if (type == DEATH_NOAMMO) {
2611                         HUD_KillNotify_Push(s1, "", 0, DEATH_NOAMMO);
2612                         if (alsoprint)
2613                                 print ("^7",s1, "^7 committed suicide. What's the point of living without ammo?\n");
2614                 } else if (type == DEATH_CAMP) {
2615                         HUD_KillNotify_Push(s1, "", 0, DEATH_CAMP);
2616                         if (alsoprint)
2617                                 print ("^1",s1, "^1 thought they found a nice camping ground\n");
2618                 } else if (type == KILL_TEAM_RED || type == KILL_TEAM_BLUE) {
2619                         HUD_KillNotify_Push(s1, "", 0, type);
2620                         if (alsoprint)
2621                                 print ("^1",s1, "^1 didn't become friends with the Lord of Teamplay\n");
2622                 } else if (type == DEATH_CHEAT) {
2623                         HUD_KillNotify_Push(s1, "", 0, DEATH_GENERIC);
2624                         if (alsoprint)
2625                                 print ("^1",s1, "^1 unfairly eliminated themself\n");
2626                 } else if (type == DEATH_FIRE) {
2627                         HUD_KillNotify_Push(s1, "", 0, DEATH_GENERIC);
2628                         if (alsoprint)
2629                                 print ("^1",s1, "^1 burned to death\n");
2630                 } else if (type != DEATH_TEAMCHANGE && type != DEATH_QUIET) {
2631                         HUD_KillNotify_Push(s1, "", 0, DEATH_GENERIC);
2632                         if (alsoprint)
2633                                 print ("^1",s1, "^1 couldn't resist the urge to self-destruct\n");
2634                 } 
2635                 
2636                 if (stof(s2) > 2) // killcount > 2
2637                         print ("^1",s1,"^1 ended it all after a ",s2," kill spree\n");
2638         } else if(msg == MSG_KILL) {
2639                 w = DEATH_WEAPONOF(type);
2640                 if(WEP_VALID(w)) {
2641                         HUD_KillNotify_Push(s1, s2, 1, type);
2642                         if (alsoprint)
2643                                 print("^1", sprintf(Weapon_KillMessage(type), strcat(s2, "^1"), strcat(s1, "^1")), "\n"); // default order: victim, killer
2644                 }
2645                 else if(type == KILL_TEAM_RED || type == KILL_TEAM_BLUE || type == KILL_TEAM_SPREE) {
2646                         HUD_KillNotify_Push(s1, s2, 1, type);
2647                         if(alsoprint)
2648                         {
2649                                 if(gentle) {
2650                                         print ("^1", s1, "^1 took action against a team mate\n");
2651                                 } else {
2652                                         print ("^1", s1, "^1 mows down a team mate\n");
2653                                 }
2654                         }
2655                         if (stof(s2) > 2 && type == KILL_TEAM_SPREE) {
2656                                 if(gentle)
2657                                         print ("^1",s1,"^1 ended a ",s3," scoring spree by going against a team mate\n");
2658                                 else
2659                                         print ("^1",s1,"^1 ended a ",s3," kill spree by killing a team mate\n");
2660                         }
2661                         else if (stof(s2) > 2) {
2662                                 if(gentle)
2663                                         print ("^1",s1,"'s ^1",s3," scoring spree was ended by a team mate!\n");
2664                                 else
2665                                         print ("^1",s1,"'s ^1",s3," kill spree was ended by a team mate!\n");
2666                         }
2667                 }
2668                 else if(type == KILL_FIRST_BLOOD)
2669                         print("^1",s1, "^1 drew first blood", "\n");
2670                 else if (type == DEATH_TELEFRAG) {
2671                         HUD_KillNotify_Push(s1, s2, 1, DEATH_TELEFRAG);
2672                         if(gentle)
2673                                 print ("^1",s2, "^1 tried to occupy ", s1, "^1's teleport destination space\n");
2674                         else
2675                                 print ("^1",s2, "^1 was telefragged by ", s1, "\n");
2676                 }
2677                 else if (type == DEATH_DROWN) {
2678                         HUD_KillNotify_Push(s1, s2, 1, DEATH_DROWN);
2679                         if(alsoprint)
2680                                 print ("^1",s2, "^1 was drowned by ", s1, "\n");
2681                 }
2682                 else if (type == DEATH_SLIME) {
2683                         HUD_KillNotify_Push(s1, s2, 1, DEATH_SLIME);
2684                         if(alsoprint)
2685                                 print ("^1",s2, "^1 was slimed by ", s1, "\n");
2686                 }
2687                 else if (type == DEATH_LAVA) {
2688                         HUD_KillNotify_Push(s1, s2, 1, DEATH_LAVA);
2689                         if(alsoprint)
2690                                 print ("^1",s2, "^1 was cooked by ", s1, "\n");
2691                 }
2692                 else if (type == DEATH_FALL) {
2693                         HUD_KillNotify_Push(s1, s2, 1, DEATH_FALL);
2694                         if(alsoprint)
2695                                 print ("^1",s2, "^1 was grounded by ", s1, "\n");
2696                 }
2697                 else if (type == DEATH_SHOOTING_STAR) {
2698                         HUD_KillNotify_Push(s1, s2, 1, DEATH_SHOOTING_STAR);
2699                         if(alsoprint)
2700                                 print ("^1",s2, "^1 was shot into space by ", s1, "\n");
2701                 }
2702                 else if (type == DEATH_SWAMP) {
2703                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2704                         if(alsoprint)
2705                                 print ("^1",s2, "^1 was conserved by ", s1, "\n");
2706                 }
2707                 else if (type == DEATH_HURTTRIGGER)
2708                 {
2709                         HUD_KillNotify_Push(s1, s2, 1, DEATH_HURTTRIGGER);
2710                         if(alsoprint)
2711                                 print("^1",s2, "^1 was thrown into a world of hurt by ", s1, "\n");
2712                 } else if(type == DEATH_SBCRUSH) {
2713                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2714                         if(alsoprint)
2715                                 print ("^1",s2, "^1 was crushed by ^1", s1, "\n");
2716                 } else if(type == DEATH_SBMINIGUN) {
2717                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2718                         if(alsoprint)
2719                                 print ("^1",s2, "^1 got shredded by ^1", s1, "\n");
2720                 } else if(type == DEATH_SBROCKET) {
2721                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2722                         if(alsoprint)
2723                                 print ("^1",s2, "^1 was blased to bits by ^1", s1, "\n");
2724                 } else if(type == DEATH_SBBLOWUP) {
2725                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2726                         if(alsoprint)
2727                                 print ("^1",s2, "^1 got caught in the destruction of ^1", s1, "'s vehicle\n");
2728                 } else if(type == DEATH_WAKIGUN) {
2729                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2730                         if(alsoprint)
2731                                 print ("^1",s2, "^1 was bolted down by ^1", s1, "\n");
2732                 } else if(type == DEATH_WAKIROCKET) {
2733                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2734                         if(alsoprint)
2735                                 print ("^1",s2, "^1 could find no shelter from ^1", s1, "'s rockets\n");
2736                 } else if(type == DEATH_WAKIBLOWUP) {
2737                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2738                         if(alsoprint)
2739                                 print ("^1",s2, "^1 dies when ^1", s1, "'s wakizashi dies.\n");
2740                 } else if(type == DEATH_TURRET) {
2741                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2742                         if(alsoprint)
2743                                 print ("^1",s2, "^1 was pushed into the line of fire by ^1", s1, "\n");
2744                 } else if(type == DEATH_TOUCHEXPLODE) {
2745                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2746                         if(alsoprint)
2747                                 print ("^1",s2, "^1 was pushed into an accident by ^1", s1, "\n");
2748                 } else if(type == DEATH_CHEAT) {
2749                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2750                         if(alsoprint)
2751                                 print ("^1",s2, "^1 was unfairly eliminated by ^1", s1, "\n");
2752                 } else if (type == DEATH_FIRE) {
2753                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2754                         if(alsoprint)
2755                                 print ("^1",s2, "^1 was burnt to death by ^1", s1, "\n");
2756                 } else if (type == DEATH_CUSTOM) {
2757                         HUD_KillNotify_Push(s1, s2, 1, DEATH_CUSTOM);
2758                         if(alsoprint)
2759                                 print("^1", sprintf(s3, strcat(s2, "^1"), strcat(s1, "^1")), "\n");
2760                 } else if (type == DEATH_HURTTRIGGER) {
2761                         HUD_KillNotify_Push(s1, s2, 1, DEATH_HURTTRIGGER);
2762                         if(alsoprint)
2763                                 print("^1", sprintf(s3, strcat(s2, "^1"), strcat(s1, "^1")), "\n");
2764                 } else {
2765                         HUD_KillNotify_Push(s1, s2, 1, DEATH_GENERIC);
2766                         if(alsoprint)
2767                                 print ("^1",s2, "^1 was fragged by ", s1, "\n");
2768                 }
2769         } else if(msg == MSG_SPREE) {
2770                 if(type == KILL_END_SPREE) {
2771                         if(gentle)
2772                                 print ("^1",s1,"'s ^1", s2, " scoring spree was ended by ", s3, "\n");
2773    &n