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