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