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 ( key_pressed )
 675         {
 676                 if ( nPrimary == K_MOUSE1 && HUD_MinigameMenu_activeitem &&
 677                         HUD_mouse_over(HUD_PANEL(MINIGAMEMENU)) )
 678                 {
 679                         HUD_MinigameMenu_Click(HUD_MinigameMenu_activeitem);
 680                         return true;
 681                 }
 682                 if ( nPrimary == K_UPARROW || nPrimary == K_KP_UPARROW )
 683                 {
 684                         if ( HUD_MinigameMenu_activeitem && HUD_MinigameMenu_activeitem.list_prev )
 685                                 HUD_MinigameMenu_activeitem = HUD_MinigameMenu_activeitem.list_prev;
 686                         else
 687                                 HUD_MinigameMenu_activeitem = HUD_MinigameMenu_last_entry;
 688                         return true;
 689                 }
 690                 else if ( nPrimary == K_DOWNARROW || nPrimary == K_KP_DOWNARROW )
 691                 {
 692                         if ( HUD_MinigameMenu_activeitem && HUD_MinigameMenu_activeitem.list_next )
 693                                 HUD_MinigameMenu_activeitem = HUD_MinigameMenu_activeitem.list_next;
 694                         else
 695                                 HUD_MinigameMenu_activeitem = HUD_MinigameMenu_entries;
 696                         return true;
 697                 }
 698                 else if ( nPrimary == K_HOME || nPrimary == K_KP_HOME )
 699                 {
 700                         HUD_MinigameMenu_activeitem = HUD_MinigameMenu_entries;
 701                         return true;
 702                 }
 703                 else if ( nPrimary == K_END || nPrimary == K_KP_END )
 704                 {
 705                         HUD_MinigameMenu_activeitem = HUD_MinigameMenu_entries;
 706                         return true;
 707                 }
 708                 else if ( nPrimary == K_KP_ENTER || nPrimary == K_ENTER || nPrimary == K_SPACE )
 709                 {
 710                         HUD_MinigameMenu_Click(HUD_MinigameMenu_activeitem);
 711                         return true;
 712                 }
 713                 else if ( nPrimary == K_ESCAPE )
 714                 {
 715                         HUD_MinigameMenu_Close(NULL, NULL, NULL);
 716                         return true;
 717                 }
 718         }
 719
 720         return false;
 721 }
 722
 723 void HUD_Minigame_Mouse()
 724 {
 725         if( !HUD_MinigameMenu_IsOpened() || autocvar__hud_configure || mv_active )
 726                 return;
 727
 728         if ( HUD_MinigameMenu_IsOpened() && HUD_mouse_over(HUD_PANEL(MINIGAMEMENU)) )
 729                 HUD_MinigameMenu_MouseInput();
 730 }