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