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