Merge branch 'master' into terencehill/hud_cleanups
[xonotic/xonotic-data.pk3dir.git] / qcsrc / common / minigames / cl_minigames_hud.qc
1 #include "cl_minigames_hud.qh"
2 #include "minigames.qh"
3
4 // whether the mouse is over the given panel
5 bool HUD_mouse_over(entity somepanel)
6 {
7         vector pos = stov(cvar_string(strcat("hud_panel_", somepanel.panel_name, "_pos")));
8         vector sz = stov(cvar_string(strcat("hud_panel_", somepanel.panel_name, "_size")));
9         return mousepos_x >= pos_x*vid_conwidth  && mousepos_x <= (pos_x+sz_x)*vid_conwidth &&
10                mousepos_y >= pos_y*vid_conheight && mousepos_y <= (pos_y+sz_y)*vid_conheight ;
11 }
12
13 // ====================================================================
14 // Minigame Board
15 // ====================================================================
16
17 // Draws the minigame game board
18 void HUD_MinigameBoard ()
19 {
20         entity hud_minigame = world;
21
22         if(!autocvar__hud_configure)
23                 hud_minigame = active_minigame.descriptor;
24         else
25                 hud_minigame = minigame_get_descriptor("nmm");
26
27         if ( !hud_minigame )
28                 return;
29
30         HUD_Panel_UpdateCvars();
31
32
33         vector pos, mySize;
34         pos = panel_pos;
35         mySize = panel_size;
36
37         hud_minigame.minigame_hud_board(pos,mySize);
38 }
39
40 // ====================================================================
41 // Minigame Status
42 // ====================================================================
43 // Draws the minigame status panel
44 void HUD_MinigameStatus ()
45 {
46         entity hud_minigame = world;
47
48         if(!autocvar__hud_configure)
49                 hud_minigame = active_minigame.descriptor;
50         else
51                 hud_minigame = minigame_get_descriptor("nmm");
52
53         if ( !hud_minigame )
54                 return;
55
56         HUD_Panel_UpdateCvars();
57
58
59         vector pos, mySize;
60         pos = panel_pos;
61         mySize = panel_size;
62
63         if(panel_bg_padding)
64         {
65                 pos += '1 1 0' * panel_bg_padding;
66                 mySize -= '2 2 0' * panel_bg_padding;
67         }
68
69         hud_minigame.minigame_hud_status(pos,mySize);
70 }
71
72 // ====================================================================
73 // Minigame Menu
74 // ====================================================================
75
76 // Minigame menu options: list head
77 entity HUD_MinigameMenu_entries;
78 // Minigame menu options: list tail
79 entity HUD_MinigameMenu_last_entry;
80
81 // Minigame menu options: insert entry after the given location
82 void HUD_MinigameMenu_InsertEntry(entity newentry, entity prev)
83 {
84         if ( !HUD_MinigameMenu_entries )
85         {
86                 HUD_MinigameMenu_entries = newentry;
87                 HUD_MinigameMenu_last_entry = newentry;
88                 return;
89         }
90
91         newentry.list_prev = prev;
92         newentry.list_next = prev.list_next;
93         if ( prev.list_next )
94                 prev.list_next.list_prev = newentry;
95         else
96                 HUD_MinigameMenu_last_entry = newentry;
97         prev.list_next = newentry;
98
99 }
100
101
102 // minigame menu item uder the mouse
103 entity HUD_MinigameMenu_activeitem;
104
105 // Click the given item
106 void HUD_MinigameMenu_Click(entity menuitem)
107 {SELFPARAM();
108         if ( menuitem )
109         {
110                 WITH(entity, self, menuitem, menuitem.use());
111         }
112 }
113
114 // Minigame menu options: Remove the given entry
115 // Precondition: the given entry is actually in the list
116 void HUD_MinigameMenu_EraseEntry ( entity e )
117 {
118         // remove child items (if any)
119         if ( e.flags & 2 )
120         {
121                 HUD_MinigameMenu_Click(e);
122         }
123
124         if ( e.list_prev )
125                 e.list_prev.list_next = e.list_next;
126         else
127                 HUD_MinigameMenu_entries = e.list_next;
128
129         if ( e.list_next )
130                 e.list_next.list_prev = e.list_prev;
131         else
132                 HUD_MinigameMenu_last_entry = e.list_prev;
133
134         if ( HUD_MinigameMenu_activeitem == e )
135                 HUD_MinigameMenu_activeitem = world;
136
137         remove(e);
138 }
139
140 // Minigame menu options: create entry
141 entity HUD_MinigameMenu_SpawnEntry(string s, vector offset, vector fontsize, vector color,void() click)
142 {
143         entity entry = spawn();
144         entry.message = s;
145         entry.origin = offset;
146         entry.size = fontsize;
147         entry.colormod = color;
148         entry.flags = 0;
149         entry.use = click;
150         panel_pos_y += fontsize_y;
151         return entry;
152 }
153
154 // Spawn a child entry of a collapsable entry
155 entity HUD_MinigameMenu_SpawnSubEntry(string s, void() click, entity parent)
156 {
157         vector item_fontsize = hud_fontsize*1.25;
158         vector item_offset = '1 0 0' * item_fontsize_x;
159         entity item = HUD_MinigameMenu_SpawnEntry(
160                                 s,item_offset,item_fontsize,'0.8 0.8 0.8', click );
161         item.owner = parent;
162         return item;
163 }
164
165 // Click action for Create sub-entries
166 void HUD_MinigameMenu_ClickCreate_Entry()
167 {SELFPARAM();
168         minigame_cmd("create ",self.netname);
169 }
170
171 // Helper click action for collapsible entries
172 // returns true when you have to create the sub-entries
173 bool HUD_MinigameMenu_Click_ExpandCollapse()
174 {SELFPARAM();
175         entity e;
176         if ( self.flags & 2 )
177         {
178                 if ( HUD_MinigameMenu_activeitem &&
179                                 HUD_MinigameMenu_activeitem.owner == self )
180                         HUD_MinigameMenu_activeitem = world;
181                 self.flags &= ~2;
182                 for ( e = self.list_next; e != world && e.owner == self; e = self.list_next )
183                 {
184                         if ( e.flags & 2 )
185                                 HUD_MinigameMenu_Click(e);
186                         self.list_next = e.list_next;
187                         remove(e);
188                 }
189                 if ( self.list_next )
190                         self.list_next.list_prev = self;
191                 else
192                         HUD_MinigameMenu_last_entry = self;
193         }
194         else
195         {
196                 for ( e = HUD_MinigameMenu_entries; e != world; e = e.list_next )
197                 {
198                         if ( e.flags & 2 && e.origin_x == self.origin_x)
199                                 HUD_MinigameMenu_Click(e);
200                 }
201
202                 self.flags |= 2;
203
204                 return true;
205         }
206         return false;
207 }
208
209 // Click action for the Create menu
210 void HUD_MinigameMenu_ClickCreate()
211 {SELFPARAM();
212         if ( HUD_MinigameMenu_Click_ExpandCollapse() )
213         {
214                 entity curr;
215                 entity prev = self;
216                 FOREACH(Minigames, true, LAMBDA(
217                 {
218                         curr = HUD_MinigameMenu_SpawnSubEntry(
219                                 it.message, HUD_MinigameMenu_ClickCreate_Entry,  self );
220                         curr.netname = it.netname;
221                         curr.model = strzone(minigame_texture(strcat(it.netname,"/icon")));
222                         HUD_MinigameMenu_InsertEntry( curr, prev );
223                         prev = curr;
224                 }));
225         }
226 }
227
228 // Click action for Join sub-entries
229 void HUD_MinigameMenu_ClickJoin_Entry()
230 {SELFPARAM();
231         minigame_cmd("join ",self.netname);
232         HUD_MinigameMenu_EraseEntry(self);
233 }
234
235 // Click action for the Join menu
236 void HUD_MinigameMenu_ClickJoin()
237 {SELFPARAM();
238         if ( HUD_MinigameMenu_Click_ExpandCollapse() )
239         {
240                 entity e = world;
241                 entity curr;
242                 entity prev = self;
243                 while( (e = find(e,classname,"minigame")) )
244                 {
245                         if ( e != active_minigame )
246                         {
247                                 curr = HUD_MinigameMenu_SpawnSubEntry(
248                                         e.netname, HUD_MinigameMenu_ClickJoin_Entry, self );
249                                 curr.netname = e.netname;
250                                 curr.model = strzone(minigame_texture(strcat(e.descriptor.netname,"/icon")));
251                                 HUD_MinigameMenu_InsertEntry( curr, prev );
252                                 prev = curr;
253                         }
254                 }
255         }
256 }
257
258 /*// Temporary placeholder for un-implemented Click actions
259 void HUD_MinigameMenu_ClickNoop()
260 {
261         dprint("Placeholder for ",self.message,"\n");
262 }*/
263
264 // Click action for Quit
265 void HUD_MinigameMenu_ClickQuit()
266 {
267         deactivate_minigame();
268         minigame_cmd("end");
269 }
270
271 // Click action for Invite sub-entries
272 void HUD_MinigameMenu_ClickInvite_Entry()
273 {SELFPARAM();
274         minigame_cmd("invite #",self.netname);
275 }
276
277 // Click action for the Invite menu
278 void HUD_MinigameMenu_ClickInvite()
279 {SELFPARAM();
280         if ( HUD_MinigameMenu_Click_ExpandCollapse() )
281         {
282                 entity e;
283                 entity prev = self;
284                 for(int i = 0; i < maxclients; ++i)
285                 {
286                         if ( player_localnum != i && playerslots[i] && GetPlayerName(i) != "" &&
287                                 !findfloat(world,minigame_playerslot,i+1) && playerslots[i].ping )
288                         {
289                                 e = HUD_MinigameMenu_SpawnSubEntry(
290                                         strzone(GetPlayerName(i)), HUD_MinigameMenu_ClickInvite_Entry,
291                                         self );
292                                 e.flags |= 1;
293                                 e.netname = strzone(ftos(i+1));
294                                 e.origin_x *= 2;
295                                 HUD_MinigameMenu_InsertEntry(e,prev);
296                                 prev = e;
297                         }
298                 }
299         }
300 }
301
302 void HUD_MinigameMenu_ClickCustomEntry()
303 {SELFPARAM();
304         if ( active_minigame )
305                 active_minigame.minigame_event(active_minigame,"menu_click",self.netname);
306 }
307
308 // Adds a game-specific entry to the menu
309 void HUD_MinigameMenu_CustomEntry(entity parent, string menumessage, string event_arg)
310 {
311         entity e = HUD_MinigameMenu_SpawnSubEntry(
312                 menumessage, HUD_MinigameMenu_ClickCustomEntry, parent );
313         e.netname = event_arg;
314         HUD_MinigameMenu_InsertEntry(e, parent);
315         //dprint("CustomEntry ",ftos(num_for_edict(parent))," ",menumessage," ",event_arg,"\n");
316 }
317
318 // Click action for the Current Game menu
319 void HUD_MinigameMenu_ClickCurrentGame()
320 {SELFPARAM();
321         if ( HUD_MinigameMenu_Click_ExpandCollapse() )
322         {
323                 HUD_MinigameMenu_InsertEntry( HUD_MinigameMenu_SpawnSubEntry(
324                         _("Quit"), HUD_MinigameMenu_ClickQuit, self ), self);
325
326                 active_minigame.minigame_event(active_minigame,"menu_show",self);
327
328                 HUD_MinigameMenu_InsertEntry( HUD_MinigameMenu_SpawnSubEntry(
329                         _("Invite"), HUD_MinigameMenu_ClickInvite, self), self);
330         }
331 }
332 // Whether the minigame menu panel is open
333 bool HUD_MinigameMenu_IsOpened()
334 {
335         return !!HUD_MinigameMenu_entries;
336 }
337
338 // Close the minigame menu panel
339 void HUD_MinigameMenu_Close()
340 {
341         if ( HUD_MinigameMenu_IsOpened() )
342         {
343                 entity e, p;
344                 for ( e = HUD_MinigameMenu_entries; e != world; e = p )
345                 {
346                         p = e.list_next;
347                         remove(e);
348                 }
349                 HUD_MinigameMenu_entries = world;
350                 HUD_MinigameMenu_last_entry = world;
351                 HUD_MinigameMenu_activeitem = world;
352                 if(autocvar_hud_cursormode)
353                 if ( !autocvar__hud_configure )
354                         setcursormode(0);
355         }
356 }
357
358 // toggle a button to manage the current game
359 void HUD_MinigameMenu_CurrentButton()
360 {
361         entity e;
362         if ( active_minigame )
363         {
364                 for ( e = HUD_MinigameMenu_last_entry; e != world; e = e.list_prev )
365                         if ( e.classname == "hud_minigamemenu_exit" )
366                         {
367                                 HUD_MinigameMenu_EraseEntry(e);
368                                 break;
369                         }
370                 entity currb = HUD_MinigameMenu_SpawnEntry(
371                         _("Current Game"), '0 0 0', hud_fontsize*1.5,'0.7 0.84 1', HUD_MinigameMenu_ClickCurrentGame );
372                 currb.classname = "hud_minigamemenu_current";
373                 currb.model = strzone(minigame_texture(strcat(active_minigame.descriptor.netname,"/icon")));
374                 HUD_MinigameMenu_InsertEntry(currb,HUD_MinigameMenu_last_entry);
375                 HUD_MinigameMenu_Click(currb);
376         }
377         else
378         {
379                 entity p;
380                 for ( e = HUD_MinigameMenu_last_entry; e != world; e = p.list_prev )
381                 {
382                         p = e;
383                         if ( e.classname == "hud_minigamemenu_current" )
384                         {
385                                 p = e.list_next;
386                                 if ( !p )
387                                         p = HUD_MinigameMenu_last_entry;
388                                 HUD_MinigameMenu_EraseEntry(e);
389                                 break;
390                         }
391                 }
392                 for ( e = HUD_MinigameMenu_last_entry; e != world; e = e.list_prev )
393                         if ( e.classname == "hud_minigamemenu_exit" )
394                                 return;
395                 entity exit = HUD_MinigameMenu_SpawnEntry(
396                         _("Exit Menu"),'0 0 0',hud_fontsize*1.5,'0.7 0.84 1', HUD_MinigameMenu_Close);
397                 exit.classname = "hud_minigamemenu_exit";
398                 HUD_MinigameMenu_InsertEntry ( exit, HUD_MinigameMenu_last_entry );
399         }
400 }
401
402 // Open the minigame menu panel
403 void HUD_MinigameMenu_Open()
404 {
405         if ( !HUD_MinigameMenu_IsOpened() )
406         {
407                 HUD_MinigameMenu_InsertEntry( HUD_MinigameMenu_SpawnEntry(
408                         _("Create"), '0 0 0', hud_fontsize*1.5,'0.7 0.84 1', HUD_MinigameMenu_ClickCreate),
409                         HUD_MinigameMenu_last_entry );
410                 HUD_MinigameMenu_InsertEntry ( HUD_MinigameMenu_SpawnEntry(
411                         _("Join"),'0 0 0',hud_fontsize*1.5,'0.7 0.84 1', HUD_MinigameMenu_ClickJoin),
412                         HUD_MinigameMenu_last_entry );
413                 HUD_MinigameMenu_CurrentButton();
414                 HUD_MinigameMenu_activeitem = world;
415                 if(autocvar_hud_cursormode)
416                         setcursormode(1);
417         }
418 }
419
420 // Handles mouse input on to minigame menu panel
421 void HUD_MinigameMenu_MouseInput()
422 {
423         panel = HUD_PANEL(MINIGAME_MENU);
424
425         HUD_Panel_UpdateCvars();
426
427         if(panel_bg_padding)
428         {
429                 panel_pos += '1 1 0' * panel_bg_padding;
430                 panel_size -= '2 2 0' * panel_bg_padding;
431         }
432
433         entity e;
434
435         panel_pos_y += hud_fontsize_y*2;
436
437         HUD_MinigameMenu_activeitem = world;
438         vector sz;
439         for ( e = HUD_MinigameMenu_entries; e != world; e = e.list_next )
440         {
441                 sz = eX*panel_size_x + eY*e.size_y;
442                 if ( e.model )
443                         sz_y = 22;
444                 if ( !HUD_MinigameMenu_activeitem && mousepos_y >= panel_pos_y && mousepos_y <= panel_pos_y + sz_y )
445                 {
446                         HUD_MinigameMenu_activeitem = e;
447                 }
448                 panel_pos_y += sz_y;
449         }
450 }
451
452 // Draw a menu entry
453 void HUD_MinigameMenu_DrawEntry(vector pos, string s, vector fontsize, vector color)
454 {
455         minigame_drawstring_trunc(panel_size_x-pos_x+panel_pos_x, pos, s,
456                                                           fontsize, color, panel_fg_alpha, DRAWFLAG_NORMAL);
457 }
458 // Draw a color-coded menu
459 void HUD_MinigameMenu_DrawColoredEntry(vector pos, string s, vector fontsize)
460 {
461         minigame_drawcolorcodedstring_trunc(panel_size_x-pos_x+panel_pos_x, pos, s,
462                                                           fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
463 }
464
465 // Minigame menu panel UI
466 void HUD_MinigameMenu ()
467 {
468         if ( !HUD_MinigameMenu_IsOpened() )
469                 return;
470
471         HUD_Panel_UpdateCvars();
472
473         HUD_Panel_DrawBg(1);
474
475         if(panel_bg_padding)
476         {
477                 panel_pos += '1 1 0' * panel_bg_padding;
478                 panel_size -= '2 2 0' * panel_bg_padding;
479         }
480
481         HUD_MinigameMenu_DrawEntry(panel_pos,_("Minigames"),hud_fontsize*2,'0.25 0.47 0.72');
482         panel_pos_y += hud_fontsize_y*2;
483
484         vector color;
485         vector offset;
486         float itemh;
487         vector imgsz = '22 22 0'; // NOTE: if changed, edit where HUD_MinigameMenu_activeitem is selected
488         for ( entity e = HUD_MinigameMenu_entries; e != world; e = e.list_next )
489         {
490                 color = e.colormod;
491
492                 offset = e.origin;
493                 itemh = e.size_y;
494
495                 if ( e.model )
496                         itemh = imgsz_y;
497
498                 if ( e.flags & 2 )
499                 {
500                         drawfill(panel_pos, eX*panel_size_x + eY*itemh, e.colormod,
501                                         panel_fg_alpha, DRAWFLAG_NORMAL);
502                         color = '0 0 0';
503                 }
504
505                 if ( e.model )
506                 {
507                         drawpic( panel_pos+offset, e.model, imgsz, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
508                         offset_x += imgsz_x;
509                         offset_y = (imgsz_y-e.size_y) / 2;
510                 }
511
512                 if ( e.flags & 1 )
513                         HUD_MinigameMenu_DrawColoredEntry(panel_pos+offset,e.message,e.size);
514                 else
515                         HUD_MinigameMenu_DrawEntry(panel_pos+offset,e.message,e.size,color);
516
517                 if ( e == HUD_MinigameMenu_activeitem )
518                         drawfill(panel_pos, eX*panel_size_x + eY*itemh,'1 1 1', 0.25, DRAWFLAG_ADDITIVE);
519
520                 panel_pos_y += itemh;
521         }
522 }
523
524 // ====================================================================
525 // Minigame Help Panel
526 // ====================================================================
527
528 void HUD_MinigameHelp()
529 {
530         string help_message;
531
532         if(!autocvar__hud_configure)
533                 help_message = active_minigame.message;
534         else
535                 help_message = "Minigame message";
536
537         if ( !help_message )
538                 return;
539
540         HUD_Panel_UpdateCvars();
541
542
543         vector pos, mySize;
544         pos = panel_pos;
545         mySize = panel_size;
546
547         if(panel_bg_padding)
548         {
549                 pos += '1 1 0' * panel_bg_padding;
550                 mySize -= '2 2 0' * panel_bg_padding;
551         }
552
553         minigame_drawcolorcodedstring_wrapped( mySize_x, pos, help_message,
554                 hud_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5 );
555 }
556
557 // ====================================================================
558 // Minigame Panel Input
559 // ====================================================================
560 float HUD_Minigame_InputEvent(float bInputType, float nPrimary, float nSecondary)
561 {
562
563         if( !HUD_MinigameMenu_IsOpened() || autocvar__hud_configure )
564                 return false;
565
566         if(bInputType == 3)
567         {
568                 mousepos_x = nPrimary;
569                 mousepos_y = nSecondary;
570                 if ( minigame_isactive() && HUD_mouse_over(HUD_PANEL(MINIGAME_BOARD)) )
571                         active_minigame.minigame_event(active_minigame,"mouse_moved",mousepos);
572                 return true;
573
574         }
575         else
576         {
577                 if(bInputType == 0) {
578                         if(nPrimary == K_ALT) hudShiftState |= S_ALT;
579                         if(nPrimary == K_CTRL) hudShiftState |= S_CTRL;
580                         if(nPrimary == K_SHIFT) hudShiftState |= S_SHIFT;
581                         if(nPrimary == K_MOUSE1) mouseClicked |= S_MOUSE1;
582                         if(nPrimary == K_MOUSE2) mouseClicked |= S_MOUSE2;
583                 }
584                 else if(bInputType == 1) {
585                         if(nPrimary == K_ALT) hudShiftState -= (hudShiftState & S_ALT);
586                         if(nPrimary == K_CTRL) hudShiftState -= (hudShiftState & S_CTRL);
587                         if(nPrimary == K_SHIFT) hudShiftState -= (hudShiftState & S_SHIFT);
588                         if(nPrimary == K_MOUSE1) mouseClicked -= (mouseClicked & S_MOUSE1);
589                         if(nPrimary == K_MOUSE2) mouseClicked -= (mouseClicked & S_MOUSE2);
590                 }
591
592                 // allow some binds
593                 string con_keys;
594                 con_keys = findkeysforcommand("toggleconsole", 0);
595                 int keys = tokenize(con_keys); // findkeysforcommand returns data for this
596                 for (int i = 0; i < keys; ++i)
597                 {
598                         if(nPrimary == stof(argv(i)))
599                                 return false;
600                 }
601
602                 if ( minigame_isactive() && ( bInputType == 0 || bInputType == 1 ) )
603                 {
604                         string device = "";
605                         string action = bInputType == 0 ? "pressed" : "released";
606                         if ( nPrimary >= K_MOUSE1 && nPrimary <= K_MOUSE16 )
607                         {
608                                 if ( HUD_mouse_over(HUD_PANEL(MINIGAME_BOARD)) )
609                                         device = "mouse";
610                         }
611                         else
612                                 device = "key";
613
614                         if ( device && active_minigame.minigame_event(
615                                         active_minigame,strcat(device,"_",action),nPrimary) )
616                                 return true;
617
618                         /// TODO: bInputType == 2?
619                 }
620
621                 if ( bInputType == 0 )
622                 {
623                         if ( nPrimary == K_MOUSE1 && HUD_MinigameMenu_activeitem &&
624                                 HUD_mouse_over(HUD_PANEL(MINIGAME_MENU)) )
625                         {
626                                 HUD_MinigameMenu_Click(HUD_MinigameMenu_activeitem);
627                                 return true;
628                         }
629                         if ( nPrimary == K_UPARROW || nPrimary == K_KP_UPARROW )
630                         {
631                                 if ( HUD_MinigameMenu_activeitem && HUD_MinigameMenu_activeitem.list_prev )
632                                         HUD_MinigameMenu_activeitem = HUD_MinigameMenu_activeitem.list_prev;
633                                 else
634                                         HUD_MinigameMenu_activeitem = HUD_MinigameMenu_last_entry;
635                                 return true;
636                         }
637                         else if ( nPrimary == K_DOWNARROW || nPrimary == K_KP_DOWNARROW )
638                         {
639                                 if ( HUD_MinigameMenu_activeitem && HUD_MinigameMenu_activeitem.list_next )
640                                         HUD_MinigameMenu_activeitem = HUD_MinigameMenu_activeitem.list_next;
641                                 else
642                                         HUD_MinigameMenu_activeitem = HUD_MinigameMenu_entries;
643                                 return true;
644                         }
645                         else if ( nPrimary == K_HOME || nPrimary == K_KP_HOME )
646                         {
647                                 HUD_MinigameMenu_activeitem = HUD_MinigameMenu_entries;
648                                 return true;
649                         }
650                         else if ( nPrimary == K_END || nPrimary == K_KP_END )
651                         {
652                                 HUD_MinigameMenu_activeitem = HUD_MinigameMenu_entries;
653                                 return true;
654                         }
655                         else if ( nPrimary == K_KP_ENTER || nPrimary == K_ENTER || nPrimary == K_SPACE )
656                         {
657                                 HUD_MinigameMenu_Click(HUD_MinigameMenu_activeitem);
658                                 return true;
659                         }
660                         else if ( nPrimary == K_ESCAPE )
661                         {
662                                 HUD_MinigameMenu_Close();
663                                 return true;
664                         }
665                 }
666         }
667
668         return false;
669
670 }
671
672 void HUD_Minigame_Mouse()
673 {
674         if( !HUD_MinigameMenu_IsOpened() || autocvar__hud_configure || mv_active )
675                 return;
676
677         if(!autocvar_hud_cursormode)
678         {
679                 mousepos = mousepos + getmousepos() * autocvar_menu_mouse_speed;
680
681                 mousepos_x = bound(0, mousepos_x, vid_conwidth);
682                 mousepos_y = bound(0, mousepos_y, vid_conheight);
683         }
684
685         if ( HUD_MinigameMenu_IsOpened() && HUD_mouse_over(HUD_PANEL(MINIGAME_MENU)) )
686                 HUD_MinigameMenu_MouseInput();
687
688         vector cursorsize = '32 32 0';
689         drawpic(mousepos-'8 4 0', strcat("gfx/menu/", autocvar_menu_skin, "/cursor.tga"),
690                         cursorsize, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
691 }
692
693 bool HUD_Minigame_Showpanels()
694 {
695         return (HUD_MinigameMenu_IsOpened() && minigame_isactive());
696 }