qcsrc/common/minigames/cl_minigames_hud.qc

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