qcsrc/client/mapvoting.qc

   1 #include "mapvoting.qh"
   2 #include "_all.qh"
   3
   4 #include "hud.qh"
   5 #include "scoreboard.qh"
   6
   7 #include "../common/mapinfo.qh"
   8 #include "../common/util.qh"
   9
  10 #include "../dpdefs/keycodes.qh"
  11
  12
  13 int mv_num_maps;
  14
  15 string mv_maps[MAPVOTE_COUNT];
  16 string mv_pics[MAPVOTE_COUNT];
  17 string mv_pk3[MAPVOTE_COUNT]; // map pk3 name or gametype human readable name
  18 string mv_desc[MAPVOTE_COUNT];
  19 float mv_preview[MAPVOTE_COUNT];
  20 float mv_votes[MAPVOTE_COUNT];
  21 float mv_flags[MAPVOTE_COUNT];
  22 float mv_flags_start[MAPVOTE_COUNT];
  23 entity mv_pk3list;
  24 float mv_abstain;
  25 float mv_ownvote;
  26 float mv_detail;
  27 float mv_timeout;
  28 float mv_top2_time;
  29 float mv_top2_alpha;
  30
  31 vector mv_mousepos;
  32 int mv_selection;
  33 int mv_columns;
  34 int mv_mouse_selection;
  35 int mv_selection_keyboard;
  36
  37 float gametypevote;
  38 string mapvote_chosenmap;
  39 vector gtv_text_size;
  40 vector gtv_text_size_small;
  41
  42 const int NUM_SSDIRS = 4;
  43 string ssdirs[NUM_SSDIRS];
  44 int n_ssdirs;
  45
  46 string MapVote_FormatMapItem(int id, string map, float _count, float maxwidth, vector fontsize)
  47 {
  48         string pre, post;
  49         pre = sprintf("%d. ", id+1);
  50         if(mv_detail)
  51         {
  52                 if(_count == 1)
  53                         post = _(" (1 vote)");
  54                 else if(_count >= 0 && (mv_flags[id] & GTV_AVAILABLE))
  55                         post = sprintf(_(" (%d votes)"), _count);
  56                 else
  57                         post = "";
  58         }
  59         else
  60                 post = "";
  61         maxwidth -= stringwidth(pre, false, fontsize) + stringwidth(post, false, fontsize);
  62         map = textShortenToWidth(map, maxwidth, fontsize, stringwidth_nocolors);
  63         return strcat(pre, map, post);
  64 }
  65
  66 vector MapVote_RGB(int id)
  67 {
  68         if(!(mv_flags[id] & GTV_AVAILABLE))
  69                 return '1 1 1';
  70         if(id == mv_ownvote)
  71                 return '0 1 0';
  72         else if (id == mv_selection)
  73                 return '1 1 0';
  74         else
  75                 return '1 1 1';
  76 }
  77
  78 void GameTypeVote_DrawGameTypeItem(vector pos, float maxh, float tsize, string gtype, string pic, float _count, int id)
  79 {
  80         // Find the correct alpha
  81         float alpha;
  82         if(!(mv_flags_start[id] & GTV_AVAILABLE))
  83                 alpha = 0.2; // The gametype isn't supported by the map
  84         else if ( !(mv_flags[id] & GTV_AVAILABLE) && mv_top2_alpha)
  85                 alpha = mv_top2_alpha; // Fade away if not one of the top 2 choice
  86         else
  87                 alpha = 1; // Normal, full alpha
  88
  89         // Bounding box details
  90         float rect_margin = hud_fontsize.y / 2;
  91         vector rect_pos = pos - '0.5 0.5 0' * rect_margin;
  92         vector rect_size = '1 1 0';
  93         rect_size.x = tsize + rect_margin;
  94         rect_size.y = maxh + rect_margin;
  95
  96         // Highlight selected item
  97         if(id == mv_selection && (mv_flags[id] & GTV_AVAILABLE))
  98         {
  99                 drawfill(rect_pos, rect_size, '1 1 1', 0.1, DRAWFLAG_NORMAL);
 100         }
 101
 102         // Highlight current vote
 103         vector rgb = MapVote_RGB(id);
 104         if(id == mv_ownvote)
 105         {
 106                 drawfill(rect_pos, rect_size, rgb, 0.1*alpha, DRAWFLAG_NORMAL);
 107                 drawborderlines(autocvar_scoreboard_border_thickness, rect_pos, rect_size, rgb, alpha, DRAWFLAG_NORMAL);
 108         }
 109
 110         vector offset = pos;
 111
 112         float title_gap = gtv_text_size.y * 1.4; // distance between the title and the description
 113         pos.y += title_gap;
 114         maxh -= title_gap;
 115
 116         // Evaluate the image size
 117         vector image_size = '1 1 0' * gtv_text_size.x * 3;
 118         if ( maxh < image_size.y )
 119                 image_size = '1 1 0' * maxh;
 120         image_size *= 0.8;
 121         float desc_padding = gtv_text_size.x * 0.6;
 122         pos.x += image_size.x + desc_padding;
 123         tsize -= image_size.x + desc_padding;
 124
 125         // Split the description into lines
 126         entity title;
 127         title = spawn();
 128         title.message = MapVote_FormatMapItem(id, mv_pk3[id], _count, tsize, gtv_text_size);
 129
 130         string thelabel = mv_desc[id], ts;
 131         entity last = title;
 132         entity next = world;
 133         float nlines = 0;
 134         if( thelabel != "")
 135         {
 136                 float i,n = tokenizebyseparator(thelabel, "\n");
 137                 for(i = 0; i < n && maxh > (nlines+1)*gtv_text_size_small.y; ++i)
 138                 {
 139                         getWrappedLine_remaining = argv(i);
 140                         while(getWrappedLine_remaining && maxh > (nlines+1)*gtv_text_size_small.y)
 141                         {
 142                                 ts = getWrappedLine(tsize, gtv_text_size_small, stringwidth_colors);
 143                                 if (ts != "")
 144                                 {
 145                                         next = spawn();
 146                                         next.message = ts;
 147                                         next.origin = pos-offset;
 148                                         last.chain = next;
 149                                         last = next;
 150                                         pos.y += gtv_text_size_small.y;
 151                                         nlines++;
 152                                 }
 153                         }
 154                 }
 155         }
 156
 157         // Center the contents in the bounding box
 158         maxh -= max(nlines*gtv_text_size_small.y,image_size.y);
 159         if ( maxh > 0 )
 160                 offset.y += maxh/2;
 161
 162         // Draw the title
 163         drawstring(offset, title.message, gtv_text_size, rgb, alpha, DRAWFLAG_NORMAL);
 164
 165         // Draw the icon
 166         if(pic != "")
 167                 drawpic('0 1 0'*title_gap+'0.5 0 0'*desc_padding+offset, pic, image_size, '1 1 1', alpha, DRAWFLAG_NORMAL);
 168
 169         // Draw the description
 170         for ( last = title.chain; last ; )
 171         {
 172                 drawstring(last.origin+offset, last.message, gtv_text_size_small, '1 1 1', alpha, DRAWFLAG_NORMAL);
 173                 next = last;
 174                 last = last.chain;
 175                 remove(next);
 176         }
 177
 178         // Cleanup
 179         remove(title);
 180 }
 181
 182 void MapVote_DrawMapItem(vector pos, float isize, float tsize, string map, string pic, float _count, int id)
 183 {
 184         vector img_size = '0 0 0';
 185         vector rgb;
 186         string label;
 187         float text_size;
 188
 189         isize -= hud_fontsize.y; // respect the text when calculating the image size
 190
 191         rgb = MapVote_RGB(id);
 192
 193         img_size.y = isize;
 194         img_size.x = isize / 0.75; // 4:3 x can be stretched easily, height is defined in isize
 195
 196         pos.y = pos.y + img_size.y;
 197
 198         label = MapVote_FormatMapItem(id, map, _count, tsize, hud_fontsize);
 199
 200         text_size = stringwidth(label, false, hud_fontsize);
 201
 202         float theAlpha;
 203         if (!(mv_flags[id] & GTV_AVAILABLE) && mv_top2_alpha)
 204                 theAlpha = mv_top2_alpha;
 205         else
 206                 theAlpha = 1;
 207
 208         pos.x -= text_size*0.5;
 209         drawstring(pos, label, hud_fontsize, rgb, theAlpha, DRAWFLAG_NORMAL);
 210
 211         pos.x = pos.x + text_size*0.5 - img_size.x*0.5;
 212         pos.y = pos.y - img_size.y;
 213
 214         pos += autocvar_scoreboard_border_thickness * '1 1 0';
 215         img_size -= (autocvar_scoreboard_border_thickness * 2) * '1 1 0';
 216         if(pic == "")
 217         {
 218                 drawfill(pos, img_size, '.5 .5 .5', .7 * theAlpha, DRAWFLAG_NORMAL);
 219         }
 220         else
 221         {
 222                 if(drawgetimagesize(pic) == '0 0 0')
 223                         drawpic(pos, draw_UseSkinFor("nopreview_map"), img_size, '1 1 1', theAlpha, DRAWFLAG_NORMAL);
 224                 else
 225                         drawpic(pos, pic, img_size, '1 1 1', theAlpha, DRAWFLAG_NORMAL);
 226         }
 227
 228         if(id == mv_ownvote)
 229                 drawborderlines(autocvar_scoreboard_border_thickness, pos, img_size, rgb, theAlpha, DRAWFLAG_NORMAL);
 230         else
 231                 drawborderlines(autocvar_scoreboard_border_thickness, pos, img_size, '0 0 0', theAlpha, DRAWFLAG_NORMAL);
 232
 233         if(id == mv_selection && (mv_flags[id] & GTV_AVAILABLE))
 234                 drawfill(pos, img_size, '1 1 1', 0.1, DRAWFLAG_NORMAL);
 235 }
 236
 237 void MapVote_DrawAbstain(vector pos, float isize, float tsize, float _count, int id)
 238 {
 239         vector rgb;
 240         float text_size;
 241         string label;
 242
 243         rgb = MapVote_RGB(id);
 244
 245         pos.y = pos.y + hud_fontsize.y;
 246
 247         label = MapVote_FormatMapItem(id, _("Don't care"), _count, tsize, hud_fontsize);
 248
 249         text_size = stringwidth(label, false, hud_fontsize);
 250
 251         pos.x -= text_size*0.5;
 252         drawstring(pos, label, hud_fontsize, rgb, 1, DRAWFLAG_NORMAL);
 253 }
 254
 255 vector MapVote_GridVec(vector gridspec, int i, int m)
 256 {
 257         int r = i % m;
 258         return
 259                 '1 0 0' * (gridspec.x * r)
 260                 +
 261                 '0 1 0' * (gridspec.y * (i - r) / m);
 262 }
 263
 264 float MapVote_Selection(vector topleft, vector cellsize, float rows, float columns)
 265 {
 266
 267         float c, r;
 268
 269         mv_mouse_selection = -1;
 270
 271         for (r = 0; r < rows; ++r)
 272                 for (c = 0; c < columns; ++c)
 273                 {
 274                         if (mv_mousepos.x >= topleft.x + cellsize.x *  c &&
 275                                 mv_mousepos.x <= topleft.x + cellsize.x * (c + 1) &&
 276                                 mv_mousepos.y >= topleft.y + cellsize.y *  r &&
 277                                 mv_mousepos.y <= topleft.y + cellsize.y * (r + 1))
 278                         {
 279                                 mv_mouse_selection = r * columns + c;
 280                                 break;
 281                         }
 282                 }
 283
 284         if (mv_mouse_selection >= mv_num_maps)
 285                 mv_mouse_selection = -1;
 286
 287         if (mv_abstain && mv_mouse_selection < 0)
 288                 mv_mouse_selection = mv_num_maps;
 289
 290         if ( mv_selection_keyboard )
 291                 return mv_selection;
 292
 293         return mv_mouse_selection;
 294 }
 295
 296 void MapVote_Draw()
 297 {
 298         string map;
 299         int i;
 300         float tmp;
 301         vector pos;
 302         float isize;
 303         float center;
 304         float rows;
 305         float tsize;
 306         vector dist = '0 0 0';
 307
 308         if(!mv_active)
 309                 return;
 310
 311         if (!autocvar_hud_cursormode)
 312         {
 313                 vector mpos = mv_mousepos + getmousepos();
 314                 mpos.x = bound(0, mpos.x, vid_conwidth);
 315                 mpos.y = bound(0, mpos.y, vid_conheight);
 316
 317                 if ( mpos.x != mv_mousepos.x || mpos.y != mv_mousepos.y )
 318                         mv_selection_keyboard = 0;
 319                 mv_mousepos = mpos;
 320
 321         }
 322
 323         center = (vid_conwidth - 1)/2;
 324         xmin = vid_conwidth*0.05; // 5% border must suffice
 325         xmax = vid_conwidth - xmin;
 326         ymin = 20;
 327         i = autocvar_con_chatpos; //*autocvar_con_chatsize;
 328         if(i < 0)
 329                 ymax = vid_conheight + (i - autocvar_con_chat) * autocvar_con_chatsize;
 330         if(i >= 0 || ymax < (vid_conheight*0.5))
 331                 ymax = vid_conheight - ymin;
 332
 333         hud_fontsize = HUD_GetFontsize("hud_fontsize");
 334
 335         pos.y = ymin;
 336         pos.z = 0;
 337
 338         draw_beginBoldFont();
 339         map = ((gametypevote) ? _("Decide the gametype") : _("Vote for a map"));
 340         pos.x = center - stringwidth(map, false, '12 0 0');
 341         drawstring(pos, map, '24 24 0', '1 1 1', 1, DRAWFLAG_NORMAL);
 342         pos.y += 26;
 343
 344         if( mapvote_chosenmap != "" )
 345         {
 346                 pos.x = center - stringwidth(mapvote_chosenmap, false, hud_fontsize*1.5/2);
 347                 drawstring(pos, mapvote_chosenmap, hud_fontsize*1.5, '1 1 1', 1, DRAWFLAG_NORMAL);
 348                 pos.y += hud_fontsize.y*2;
 349         }
 350
 351         i = ceil(max(0, mv_timeout - time));
 352         map = sprintf(_("%d seconds left"), i);
 353         pos.x = center - stringwidth(map, false, '8 0 0');
 354         drawstring(pos, map, '16 16 0', '0 1 0', 1, DRAWFLAG_NORMAL);
 355         pos.y += 22;
 356         pos.x = xmin;
 357         draw_endBoldFont();
 358
 359         // base for multi-column stuff...
 360         ymin = pos.y;
 361         if(mv_abstain)
 362                 mv_num_maps -= 1;
 363
 364         rows = ceil(mv_num_maps / mv_columns);
 365
 366         dist.x = (xmax - xmin) / mv_columns;
 367         dist.y = (ymax - pos.y) / rows;
 368
 369         if ( gametypevote )
 370         {
 371                 tsize = dist.x - hud_fontsize.y;
 372                 isize = dist.y;
 373                 float maxheight = (ymax - pos.y) / 3;
 374                 if ( isize > maxheight )
 375                 {
 376                         pos.x += (isize - maxheight)/2;
 377                         isize = maxheight;
 378                 }
 379                 else
 380                         dist.y += hud_fontsize.y;
 381                 pos.x = ( vid_conwidth - dist.x * mv_columns ) / 2;
 382         }
 383         else
 384         {
 385                 tsize = dist.x - 10;
 386                 isize = min(dist.y - 10, 0.75 * tsize);
 387         }
 388
 389         mv_selection = MapVote_Selection(pos, dist, rows, mv_columns);
 390
 391         if ( !gametypevote )
 392                 pos.x += dist.x / 2;
 393         pos.y += (dist.y - isize) / 2;
 394         ymax -= isize;
 395
 396         if (mv_top2_time)
 397                 mv_top2_alpha = max(0.2, 1 - (time - mv_top2_time)*(time - mv_top2_time));
 398
 399         void (vector, float, float, string, string, float, float) DrawItem;
 400
 401         if(gametypevote)
 402                 DrawItem = GameTypeVote_DrawGameTypeItem;
 403         else
 404                 DrawItem = MapVote_DrawMapItem;
 405
 406         for(i = 0; i < mv_num_maps; ++i)
 407         {
 408                 tmp = mv_votes[i]; // FTEQCC bug: too many array accesses in the function call screw it up
 409                 map = mv_maps[i];
 410                 if(mv_preview[i])
 411                         DrawItem(pos + MapVote_GridVec(dist, i, mv_columns), isize, tsize, map, mv_pics[i], tmp, i);
 412                 else
 413                         DrawItem(pos + MapVote_GridVec(dist, i, mv_columns), isize, tsize, map, "", tmp, i);
 414         }
 415
 416         if(mv_abstain)
 417                 ++mv_num_maps;
 418
 419         if(mv_abstain && i < mv_num_maps) {
 420                 tmp = mv_votes[i];
 421                 pos.y = ymax + isize - hud_fontsize.y;
 422                 pos.x = (xmax+xmin)*0.5;
 423                 MapVote_DrawAbstain(pos, isize, xmax - xmin, tmp, i);
 424         }
 425
 426         drawpic(mv_mousepos, strcat("gfx/menu/", autocvar_menu_skin, "/cursor.tga"), '32 32 0', '1 1 1', 1 - autocvar__menu_alpha, DRAWFLAG_NORMAL);
 427 }
 428
 429 void Cmd_MapVote_MapDownload(float argc)
 430 {
 431         entity pak;
 432
 433         if(argc != 2 || !mv_pk3list)
 434         {
 435                 print(_("mv_mapdownload: ^3You're not supposed to use this command on your own!\n"));
 436                 return;
 437         }
 438
 439         int id = stof(argv(1));
 440         for(pak = mv_pk3list; pak; pak = pak.chain)
 441                 if(pak.sv_entnum == id)
 442                         break;
 443
 444         if(!pak || pak.sv_entnum != id) {
 445                 print(_("^1Error:^7 Couldn't find pak index.\n"));
 446                 return;
 447         }
 448
 449         if(PreviewExists(pak.message))
 450         {
 451                 mv_preview[id] = true;
 452                 return;
 453         } else {
 454                 print(_("Requesting preview...\n"));
 455                 localcmd(strcat("\ncmd mv_getpicture ", ftos(id), "\n"));
 456         }
 457 }
 458
 459 void MapVote_CheckPK3(string pic, string pk3, int id)
 460 {
 461         entity pak;
 462         pak = spawn();
 463         pak.netname = pk3;
 464         pak.message = pic;
 465         pak.sv_entnum = id;
 466
 467         pak.chain = mv_pk3list;
 468         mv_pk3list = pak;
 469
 470         if(pk3 != "")
 471         {
 472                 localcmd(strcat("\ncurl --pak ", pk3, "; wait; cl_cmd mv_download ", ftos(id), "\n"));
 473         }
 474         else
 475         {
 476                 Cmd_MapVote_MapDownload(tokenize_console(strcat("mv_download ", ftos(id))));
 477         }
 478 }
 479
 480 void MapVote_CheckPic(string pic, string pk3, int id)
 481 {
 482         // never try to retrieve a pic for the "don't care" 'map'
 483         if(mv_abstain && id == mv_num_maps - 1)
 484                 return;
 485
 486         if(PreviewExists(pic))
 487         {
 488                 mv_preview[id] = true;
 489                 return;
 490         }
 491         MapVote_CheckPK3(pic, pk3, id);
 492 }
 493
 494 void MapVote_ReadMask()
 495 {
 496         int i;
 497         if ( mv_num_maps < 24 )
 498         {
 499                 int mask, power;
 500                 if(mv_num_maps < 8)
 501                         mask = ReadByte();
 502                 else if(mv_num_maps < 16)
 503                         mask = ReadShort();
 504                 else
 505                         mask = ReadLong();
 506
 507                 for(i = 0, power = 1; i < mv_num_maps; ++i, power *= 2)
 508                 {
 509                         if ( mask & power )
 510                                 mv_flags[i] |= GTV_AVAILABLE;
 511                         else
 512                                 mv_flags[i] &= ~GTV_AVAILABLE;
 513                 }
 514         }
 515         else
 516         {
 517                 for(i = 0; i < mv_num_maps; ++i )
 518                         mv_flags[i] = ReadByte();
 519         }
 520 }
 521
 522 void MapVote_ReadOption(int i)
 523 {
 524         string map = strzone(ReadString());
 525         string pk3 = strzone(ReadString());
 526         int j = bound(0, ReadByte(), n_ssdirs - 1);
 527
 528         mv_maps[i] = map;
 529         mv_pk3[i] = pk3;
 530         mv_flags[i] = GTV_AVAILABLE;
 531
 532         string pic = strzone(strcat(ssdirs[j], "/", map));
 533         mv_pics[i] = pic;
 534         mv_preview[i] = false;
 535         MapVote_CheckPic(pic, pk3, i);
 536 }
 537
 538 void GameTypeVote_ReadOption(int i)
 539 {
 540         string gt = strzone(ReadString());
 541
 542         mv_maps[i] = gt;
 543         mv_flags[i] = ReadByte();
 544
 545         string mv_picpath = sprintf("gfx/menu/%s/gametype_%s", autocvar_menu_skin, gt);
 546         if(precache_pic(mv_picpath) == "")
 547                 mv_picpath = strcat("gfx/menu/default/gametype_", gt);
 548         string pic = strzone(mv_picpath);
 549         mv_pics[i] = pic;
 550         mv_preview[i] = PreviewExists(pic);
 551
 552         if ( mv_flags[i] & GTV_CUSTOM )
 553         {
 554                 string name = ReadString();
 555                 if ( strlen(name) < 1 )
 556                         name = gt;
 557                 mv_pk3[i] = strzone(name);
 558                 mv_desc[i] = strzone(ReadString());
 559         }
 560         else
 561         {
 562                 int type = MapInfo_Type_FromString(gt);
 563                 mv_pk3[i] = strzone(MapInfo_Type_ToText(type));
 564                 mv_desc[i] = MapInfo_Type_Description(type);
 565         }
 566 }
 567
 568 void MapVote_Init()
 569 {
 570         precache_sound ("misc/invshot.wav");
 571
 572         mv_active = 1;
 573         if(autocvar_hud_cursormode) { setcursormode(1); }
 574         else { mv_mousepos = '0.5 0 0' * vid_conwidth + '0 0.5 0' * vid_conheight; }
 575         mv_selection = -1;
 576         mv_selection_keyboard = 0;
 577
 578         string s;
 579         for(n_ssdirs = 0; ; ++n_ssdirs)
 580         {
 581                 s = ReadString();
 582                 if(s == "")
 583                         break;
 584                 if(n_ssdirs < NUM_SSDIRS)
 585                         ssdirs[n_ssdirs] = s;
 586         }
 587         n_ssdirs = min(n_ssdirs, NUM_SSDIRS);
 588
 589         mv_num_maps = min(MAPVOTE_COUNT, ReadByte());
 590         mv_abstain = ReadByte();
 591         if(mv_abstain)
 592                 mv_abstain = 1; // must be 1 for bool-true, makes stuff easier
 593         mv_detail = ReadByte();
 594
 595         mv_ownvote = -1;
 596         mv_timeout = ReadCoord();
 597
 598         gametypevote = ReadByte();
 599
 600         float mv_real_num_maps = mv_num_maps - mv_abstain;
 601
 602         if(gametypevote)
 603         {
 604                 mapvote_chosenmap = strzone(ReadString());
 605                 if ( gametypevote == 2 )
 606                         gametypevote = 0;
 607
 608                 gtv_text_size = hud_fontsize*1.4;
 609                 gtv_text_size_small = hud_fontsize*1.1;
 610
 611                 if (mv_real_num_maps > 8 )
 612                         mv_columns = 3;
 613                 else
 614                         mv_columns = min(2, mv_real_num_maps);
 615     }
 616     else
 617         {
 618                 if (mv_real_num_maps > 16)
 619                         mv_columns = 5;
 620                 else if (mv_real_num_maps > 9)
 621                         mv_columns = 4;
 622                 else if(mv_real_num_maps > 3)
 623                         mv_columns = 3;
 624                 else
 625                         mv_columns = mv_real_num_maps;
 626         }
 627
 628         MapVote_ReadMask();
 629         int i;
 630         for(i = 0; i < mv_num_maps; ++i )
 631                 mv_flags_start[i] = mv_flags[i];
 632
 633         // Assume mv_pk3list is world, there should only be 1 mapvote per round
 634         mv_pk3list = world; // I'm still paranoid!
 635
 636         for(i = 0; i < mv_num_maps; ++i)
 637         {
 638                 mv_votes[i] = 0;
 639
 640                 if ( gametypevote )
 641                         GameTypeVote_ReadOption(i);
 642                 else
 643                         MapVote_ReadOption(i);
 644         }
 645
 646         for(i = 0; i < n_ssdirs; ++i)
 647                 ssdirs[n_ssdirs] = string_null;
 648         n_ssdirs = 0;
 649 }
 650
 651 void MapVote_SendChoice(float index)
 652 {
 653         localcmd(strcat("\nimpulse ", ftos(index+1), "\n"));
 654 }
 655
 656 int MapVote_MoveLeft(int pos)
 657 {
 658         int imp;
 659         if ( pos < 0 )
 660                 imp = mv_num_maps - 1;
 661         else
 662                 imp = pos < 1 ? mv_num_maps - 1 : pos - 1;
 663         if ( !(mv_flags[imp] & GTV_AVAILABLE) && imp != mv_ownvote )
 664                 imp = MapVote_MoveLeft(imp);
 665         return imp;
 666 }
 667 int MapVote_MoveRight(int pos)
 668 {
 669         int imp;
 670         if ( pos < 0 )
 671                 imp = 0;
 672         else
 673                 imp = pos >= mv_num_maps - 1 ? 0 : pos + 1;
 674         if ( !(mv_flags[imp] & GTV_AVAILABLE) && imp != mv_ownvote )
 675                 imp = MapVote_MoveRight(imp);
 676         return imp;
 677 }
 678 int MapVote_MoveUp(int pos)
 679 {
 680         int imp;
 681         if ( pos < 0 )
 682                 imp = mv_num_maps - 1;
 683         else
 684         {
 685                 imp = pos - mv_columns;
 686                 if ( imp < 0 )
 687                 {
 688                         imp = floor(mv_num_maps/mv_columns)*mv_columns + pos % mv_columns;
 689                         if ( imp >= mv_num_maps )
 690                                 imp -= mv_columns;
 691                 }
 692         }
 693         if ( !(mv_flags[imp] & GTV_AVAILABLE) && imp != mv_ownvote )
 694                 imp = MapVote_MoveUp(imp);
 695         return imp;
 696 }
 697 int MapVote_MoveDown(int pos)
 698 {
 699         int imp;
 700         if ( pos < 0 )
 701                 imp = 0;
 702         else
 703         {
 704                 imp = pos + mv_columns;
 705                 if ( imp >= mv_num_maps )
 706                         imp = imp % mv_columns;
 707         }
 708         if ( !(mv_flags[imp] & GTV_AVAILABLE) && imp != mv_ownvote )
 709                 imp = MapVote_MoveDown(imp);
 710         return imp;
 711 }
 712
 713 float MapVote_InputEvent(float bInputType, float nPrimary, float nSecondary)
 714 {
 715         float imp;
 716
 717         if (!mv_active)
 718                 return false;
 719
 720         if(bInputType == 3)
 721         {
 722                 mv_mousepos.x = nPrimary;
 723                 mv_mousepos.y = nSecondary;
 724                 mv_selection_keyboard = 0;
 725                 return true;
 726         }
 727
 728         if (bInputType != 0)
 729                 return false;
 730
 731         if ('0' <= nPrimary && nPrimary <= '9')
 732         {
 733                 imp = nPrimary - '0';
 734                 if (imp == 0) imp = 10;
 735                 localcmd(strcat("\nimpulse ", ftos(imp), "\n"));
 736                 return true;
 737         }
 738         switch(nPrimary)
 739         {
 740                 case K_KP_1: localcmd("\nimpulse 1\n"); return true;
 741                 case K_KP_2: localcmd("\nimpulse 2\n"); return true;
 742                 case K_KP_3: localcmd("\nimpulse 3\n"); return true;
 743                 case K_KP_4: localcmd("\nimpulse 4\n"); return true;
 744                 case K_KP_5: localcmd("\nimpulse 5\n"); return true;
 745                 case K_KP_6: localcmd("\nimpulse 6\n"); return true;
 746                 case K_KP_7: localcmd("\nimpulse 7\n"); return true;
 747                 case K_KP_8: localcmd("\nimpulse 8\n"); return true;
 748                 case K_KP_9: localcmd("\nimpulse 9\n"); return true;
 749                 case K_KP_0: localcmd("\nimpulse 10\n"); return true;
 750
 751                 case K_RIGHTARROW:
 752                         mv_selection_keyboard = 1;
 753                         mv_selection = MapVote_MoveRight(mv_selection);
 754                         return true;
 755                 case K_LEFTARROW:
 756                         mv_selection_keyboard = 1;
 757                         mv_selection = MapVote_MoveLeft(mv_selection);
 758                         return true;
 759                 case K_DOWNARROW:
 760                         mv_selection_keyboard = 1;
 761                         mv_selection = MapVote_MoveDown(mv_selection);
 762                         return true;
 763                 case K_UPARROW:
 764                         mv_selection_keyboard = 1;
 765                         mv_selection = MapVote_MoveUp(mv_selection);
 766                         return true;
 767                 case K_KP_ENTER:
 768                 case K_ENTER:
 769                 case K_SPACE:
 770                         if ( mv_selection_keyboard )
 771                                 MapVote_SendChoice(mv_selection);
 772                         return true;
 773         }
 774
 775         if (nPrimary == K_MOUSE1)
 776         {
 777                 mv_selection_keyboard = 0;
 778                 mv_selection = mv_mouse_selection;
 779                 if (mv_selection >= 0)
 780                 {
 781                         imp = min(mv_selection + 1, mv_num_maps);
 782                         localcmd(strcat("\nimpulse ", ftos(imp), "\n"));
 783                         return true;
 784                 }
 785         }
 786
 787         return false;
 788 }
 789
 790 void MapVote_UpdateMask()
 791 {
 792         MapVote_ReadMask();
 793         mv_top2_time = time;
 794 }
 795
 796 void MapVote_UpdateVotes()
 797 {
 798         int i;
 799         for(i = 0; i < mv_num_maps; ++i)
 800         {
 801                 if(mv_flags[i] & GTV_AVAILABLE)
 802                 {
 803                         if(mv_detail)
 804                                 mv_votes[i] = ReadByte();
 805                         else
 806                                 mv_votes[i] = 0;
 807                 }
 808                 else
 809                         mv_votes[i] = -1;
 810         }
 811
 812         mv_ownvote = ReadByte()-1;
 813 }
 814
 815 void Ent_MapVote()
 816 {
 817         int sf = ReadByte();
 818
 819         if(sf & 1)
 820                 MapVote_Init();
 821
 822         if(sf & 2)
 823                 MapVote_UpdateMask();
 824
 825         if(sf & 4)
 826                 MapVote_UpdateVotes();
 827 }
 828
 829 void Net_MapVote_Picture()
 830 {
 831         int type = ReadByte();
 832         mv_preview[type] = true;
 833         mv_pics[type] = strzone(ReadPicture());
 834 }