qcsrc/server/command/vote.qc

   1 #if defined(CSQC)
   2 #elif defined(MENUQC)
   3 #elif defined(SVQC)
   4         #include "../../dpdefs/progsdefs.qc"
   5     #include "../../dpdefs/dpextensions.qc"
   6     #include "../sys-post.qh"
   7     #include "../../common/constants.qh"
   8     #include "../../common/util.qh"
   9     #include "../../common/command/shared_defs.qh"
  10     #include "../autocvars.qh"
  11     #include "../constants.qh"
  12     #include "../defs.qh"
  13     #include "../../common/notifications.qh"
  14     #include "../mutators/mutators_include.qh"
  15     #include "../../common/mapinfo.qh"
  16     #include "common.qh"
  17     #include "vote.qh"
  18     #include "../../common/playerstats.qh"
  19     #include "../scores.qh"
  20     #include "../race.qh"
  21     #include "../round_handler.qh"
  22 #endif
  23
  24 // =============================================
  25 //  Server side voting code, reworked by Samual
  26 //  Last updated: December 27th, 2011
  27 // =============================================
  28
  29 //  Nagger for players to know status of voting
  30 float Nagger_SendEntity(entity to, float sendflags)
  31 {
  32         float nags, i, f, b;
  33         entity e;
  34         WriteByte(MSG_ENTITY, ENT_CLIENT_NAGGER);
  35
  36         // bits:
  37         //   1 = ready
  38         //   2 = player needs to ready up
  39         //   4 = vote
  40         //   8 = player needs to vote
  41         //  16 = warmup
  42         // sendflags:
  43         //  64 = vote counts
  44         // 128 = vote string
  45
  46         nags = 0;
  47         if(readycount)
  48         {
  49                 nags |= 1;
  50                 if(to.ready == 0)
  51                         nags |= 2;
  52         }
  53         if(vote_called)
  54         {
  55                 nags |= 4;
  56                 if(to.vote_selection == 0)
  57                         nags |= 8;
  58         }
  59         if(warmup_stage)
  60                 nags |= 16;
  61
  62         if(sendflags & 64)
  63                 nags |= 64;
  64
  65         if(sendflags & 128)
  66                 nags |= 128;
  67
  68         if(!(nags & 4)) // no vote called? send no string
  69                 nags &= ~(64 | 128);
  70
  71         WriteByte(MSG_ENTITY, nags);
  72
  73         if(nags & 64)
  74         {
  75                 WriteByte(MSG_ENTITY, vote_accept_count);
  76                 WriteByte(MSG_ENTITY, vote_reject_count);
  77                 WriteByte(MSG_ENTITY, vote_needed_overall);
  78                 WriteChar(MSG_ENTITY, to.vote_selection);
  79         }
  80
  81         if(nags & 128)
  82                 WriteString(MSG_ENTITY, vote_called_display);
  83
  84         if(nags & 1)
  85         {
  86                 for(i = 1; i <= maxclients; i += 8)
  87                 {
  88                         for(f = 0, e = edict_num(i), b = 1; b < 256; b *= 2, e = nextent(e))
  89                                 if(!IS_REAL_CLIENT(e) || e.ready)
  90                                         f |= b;
  91                         WriteByte(MSG_ENTITY, f);
  92                 }
  93         }
  94
  95         return true;
  96 }
  97
  98 void Nagger_Init()
  99 {
 100         Net_LinkEntity(nagger = spawn(), false, 0, Nagger_SendEntity);
 101 }
 102
 103 void Nagger_VoteChanged()
 104 {
 105         if(nagger)
 106                 nagger.SendFlags |= 128;
 107 }
 108
 109 void Nagger_VoteCountChanged()
 110 {
 111         if(nagger)
 112                 nagger.SendFlags |= 64;
 113 }
 114
 115 void Nagger_ReadyCounted()
 116 {
 117         if(nagger)
 118                 nagger.SendFlags |= 1;
 119 }
 120
 121
 122 // =======================
 123 //  Game logic for voting
 124 // =======================
 125
 126 void VoteReset()
 127 {
 128         entity tmp_player;
 129
 130         FOR_EACH_CLIENT(tmp_player) { tmp_player.vote_selection = 0; }
 131
 132         if(vote_called)
 133         {
 134                 strunzone(vote_called_command);
 135                 strunzone(vote_called_display);
 136         }
 137
 138         vote_called = VOTE_NULL;
 139         vote_caller = world;
 140         vote_endtime = 0;
 141
 142         vote_called_command = string_null;
 143         vote_called_display = string_null;
 144
 145         vote_parsed_command = string_null;
 146         vote_parsed_display = string_null;
 147
 148         Nagger_VoteChanged();
 149 }
 150
 151 void VoteStop(entity stopper)
 152 {
 153         bprint("\{1}^2* ^3", GetCallerName(stopper), "^2 stopped ^3", GetCallerName(vote_caller), "^2's vote\n");
 154         if(autocvar_sv_eventlog) { GameLogEcho(strcat(":vote:vstop:", ftos(stopper.playerid))); }
 155
 156         // Don't force them to wait for next vote, this way they can e.g. correct their vote.
 157         if((vote_caller) && (stopper == vote_caller)) { vote_caller.vote_waittime = time + autocvar_sv_vote_stop; }
 158
 159         VoteReset();
 160 }
 161
 162 void VoteAccept()
 163 {
 164         bprint("\{1}^2* ^3", GetCallerName(vote_caller), "^2's vote for ^1", vote_called_display, "^2 was accepted\n");
 165
 166         if((vote_called == VOTE_MASTER) && vote_caller)
 167                 vote_caller.vote_master = 1;
 168         else
 169                 localcmd(strcat(vote_called_command, "\n"));
 170
 171         if(vote_caller) { vote_caller.vote_waittime = 0; } // people like your votes, you don't need to wait to vote again
 172
 173         VoteReset();
 174         Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_VOTE_ACCEPT);
 175 }
 176
 177 void VoteReject()
 178 {
 179         bprint("\{1}^2* ^3", GetCallerName(vote_caller), "^2's vote for ", vote_called_display, "^2 was rejected\n");
 180         VoteReset();
 181         Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_VOTE_FAIL);
 182 }
 183
 184 void VoteTimeout()
 185 {
 186         bprint("\{1}^2* ^3", GetCallerName(vote_caller), "^2's vote for ", vote_called_display, "^2 timed out\n");
 187         VoteReset();
 188         Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_VOTE_FAIL);
 189 }
 190
 191 void VoteSpam(float notvoters, float mincount, string result)
 192 {
 193         bprint(strcat(
 194                 strcat("\{1}^2* vote results: ^1", ftos(vote_accept_count)),
 195                 strcat("^2:^1", ftos(vote_reject_count)),
 196                 ((mincount >= 0) ? strcat("^2 (^1", ftos(mincount), "^2 needed)") : "^2"),
 197                 strcat(", ^1", ftos(vote_abstain_count), "^2 didn't care"),
 198                 strcat(", ^1", ftos(notvoters), strcat("^2 didn't ", ((mincount >= 0) ? "" : "have to "), "vote\n"))));
 199
 200         if(autocvar_sv_eventlog)
 201         {
 202                 GameLogEcho(strcat(
 203                         strcat(":vote:v", result, ":", ftos(vote_accept_count)),
 204                         strcat(":", ftos(vote_reject_count)),
 205                         strcat(":", ftos(vote_abstain_count)),
 206                         strcat(":", ftos(notvoters)),
 207                         strcat(":", ftos(mincount))));
 208         }
 209 }
 210
 211 void VoteCount(float first_count)
 212 {
 213         // declarations
 214         vote_accept_count = vote_reject_count = vote_abstain_count = 0;
 215
 216         float spectators_allowed = ((autocvar_sv_vote_nospectators != 2)
 217                                 || ((autocvar_sv_vote_nospectators == 1) && (warmup_stage || gameover))
 218                                 || (autocvar_sv_vote_nospectators == 0));
 219
 220         float vote_player_count = 0, notvoters = 0;
 221         float vote_real_player_count = 0, vote_real_accept_count = 0;
 222         float vote_real_reject_count = 0, vote_real_abstain_count = 0;
 223         float vote_needed_of_voted, final_needed_votes;
 224         float vote_factor_overall, vote_factor_of_voted;
 225
 226         entity tmp_player;
 227
 228         Nagger_VoteCountChanged();
 229
 230         // add up all the votes from each connected client
 231         FOR_EACH_REALCLIENT(tmp_player)
 232         {
 233                 ++vote_player_count;
 234                 if(IS_PLAYER(tmp_player)) { ++vote_real_player_count; }
 235
 236                 switch(tmp_player.vote_selection)
 237                 {
 238                         case VOTE_SELECT_REJECT: { ++vote_reject_count; { if(IS_PLAYER(tmp_player)) ++vote_real_reject_count; } break; }
 239                         case VOTE_SELECT_ACCEPT: { ++vote_accept_count; { if(IS_PLAYER(tmp_player)) ++vote_real_reject_count; } break; }
 240                         case VOTE_SELECT_ABSTAIN: { ++vote_abstain_count; { if(IS_PLAYER(tmp_player)) ++vote_real_abstain_count; } break; }
 241                         default: break;
 242                 }
 243         }
 244
 245         // Check to see if there are enough players on the server to allow master voting... otherwise, vote master could be used for evil.
 246         if((vote_called == VOTE_MASTER) && autocvar_sv_vote_master_playerlimit > vote_player_count)
 247         {
 248                 if(vote_caller) { vote_caller.vote_waittime = 0; }
 249                 print_to(vote_caller, "^1There are not enough players on this server to allow you to become vote master.");
 250                 VoteReset();
 251                 return;
 252         }
 253
 254         // if spectators aren't allowed to vote and there are players in a match, then only count the players in the vote and ignore spectators.
 255         if(!spectators_allowed && (vote_real_player_count > 0))
 256         {
 257                 vote_accept_count = vote_real_accept_count;
 258                 vote_reject_count = vote_real_reject_count;
 259                 vote_abstain_count = vote_real_abstain_count;
 260                 vote_player_count = vote_real_player_count;
 261         }
 262
 263         // people who have no opinion in any way :D
 264         notvoters = (vote_player_count - vote_accept_count - vote_reject_count - vote_abstain_count);
 265
 266         // determine the goal for the vote to be passed or rejected normally
 267         vote_factor_overall = bound(0.5, autocvar_sv_vote_majority_factor, 0.999);
 268         vote_needed_overall = floor((vote_player_count - vote_abstain_count) * vote_factor_overall) + 1;
 269
 270         // if the vote times out, determine the amount of votes needed of the people who actually already voted
 271         vote_factor_of_voted = bound(0.5, autocvar_sv_vote_majority_factor_of_voted, 0.999);
 272         vote_needed_of_voted = floor((vote_accept_count + vote_reject_count) * vote_factor_of_voted) + 1;
 273
 274         // are there any players at all on the server? it could be an admin vote
 275         if(vote_player_count == 0 && first_count)
 276         {
 277                 VoteSpam(0, -1, "yes"); // no players at all, just accept it
 278                 VoteAccept();
 279                 return;
 280         }
 281
 282         // since there ARE players, finally calculate the result of the vote
 283         if(vote_accept_count >= vote_needed_overall)
 284         {
 285                 VoteSpam(notvoters, -1, "yes"); // there is enough acceptions to pass the vote
 286                 VoteAccept();
 287                 return;
 288         }
 289
 290         if(vote_reject_count > vote_player_count - vote_abstain_count - vote_needed_overall)
 291         {
 292                 VoteSpam(notvoters, -1, "no"); // there is enough rejections to deny the vote
 293                 VoteReject();
 294                 return;
 295         }
 296
 297         // there is not enough votes in either direction, now lets just calculate what the voters have said
 298         if(time > vote_endtime)
 299         {
 300                 final_needed_votes = vote_needed_overall;
 301
 302                 if(autocvar_sv_vote_majority_factor_of_voted)
 303                 {
 304                         if(vote_accept_count >= vote_needed_of_voted)
 305                         {
 306                                 VoteSpam(notvoters, min(vote_needed_overall, vote_needed_of_voted), "yes");
 307                                 VoteAccept();
 308                                 return;
 309                         }
 310
 311                         if(vote_accept_count + vote_reject_count > 0)
 312                         {
 313                                 VoteSpam(notvoters, min(vote_needed_overall, vote_needed_of_voted), "no");
 314                                 VoteReject();
 315                                 return;
 316                         }
 317
 318                         final_needed_votes = min(vote_needed_overall, vote_needed_of_voted);
 319                 }
 320
 321                 // it didn't pass or fail, so not enough votes to even make a decision.
 322                 VoteSpam(notvoters, final_needed_votes, "timeout");
 323                 VoteTimeout();
 324         }
 325 }
 326
 327 void VoteThink()
 328 {
 329         if(vote_endtime > 0) // a vote was called
 330         if(time > vote_endtime) // time is up
 331         {
 332                 VoteCount(false);
 333         }
 334
 335         return;
 336 }
 337
 338
 339 // =======================
 340 //  Game logic for warmup
 341 // =======================
 342
 343 // Resets the state of all clients, items, weapons, waypoints, ... of the map.
 344 void reset_map(float dorespawn)
 345 {
 346         entity oldself;
 347         oldself = self;
 348
 349         if(time <= game_starttime && round_handler_IsActive())
 350                 round_handler_Reset(game_starttime);
 351
 352         MUTATOR_CALLHOOK(reset_map_global);
 353
 354         for(self = world; (self = nextent(self)); )
 355         if(IS_NOT_A_CLIENT(self))
 356         {
 357                 if(self.reset)
 358                 {
 359                         self.reset();
 360                         continue;
 361                 }
 362
 363                 if(self.team_saved)
 364                         self.team = self.team_saved;
 365
 366                 if(self.flags & FL_PROJECTILE) // remove any projectiles left
 367                         remove(self);
 368         }
 369
 370         // Waypoints and assault start come LAST
 371         for(self = world; (self = nextent(self)); )
 372         if(IS_NOT_A_CLIENT(self))
 373         {
 374                 if(self.reset2)
 375                 {
 376                         self.reset2();
 377                         continue;
 378                 }
 379         }
 380
 381         FOR_EACH_PLAYER(self)
 382         if(self.frozen)
 383                 Unfreeze(self);
 384
 385         // Moving the player reset code here since the player-reset depends
 386         // on spawnpoint entities which have to be reset first --blub
 387         if(dorespawn)
 388         if(!MUTATOR_CALLHOOK(reset_map_players))
 389         FOR_EACH_CLIENT(self) // reset all players
 390         {
 391                 /*
 392                 only reset players if a restart countdown is active
 393                 this can either be due to cvar sv_ready_restart_after_countdown having set
 394                 restart_mapalreadyrestarted to 1 after the countdown ended or when
 395                 sv_ready_restart_after_countdown is not used and countdown is still running
 396                 */
 397                 if (restart_mapalreadyrestarted || (time < game_starttime))
 398                 {
 399                         //NEW: changed behaviour so that it prevents that previous spectators/observers suddenly spawn as players
 400                         if (IS_PLAYER(self)) {
 401                                 //PlayerScore_Clear(self);
 402                                 self.killcount = 0;
 403                                 //stop the player from moving so that he stands still once he gets respawned
 404                                 self.velocity = '0 0 0';
 405                                 self.avelocity = '0 0 0';
 406                                 self.movement = '0 0 0';
 407                                 PutClientInServer();
 408                         }
 409                 }
 410         }
 411
 412         if(g_keyhunt)
 413                 kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_round + (game_starttime - time), kh_StartRound);
 414
 415         self = oldself;
 416 }
 417
 418 // Restarts the map after the countdown is over (and cvar sv_ready_restart_after_countdown is set)
 419 void ReadyRestart_think()
 420 {
 421         restart_mapalreadyrestarted = 1;
 422         reset_map(true);
 423         Score_ClearAll();
 424         remove(self);
 425
 426         return;
 427 }
 428
 429 // Forces a restart of the game without actually reloading the map // this is a mess...
 430 void ReadyRestart_force()
 431 {
 432         entity tmp_player, restart_timer;
 433
 434         bprint("^1Server is restarting...\n");
 435
 436         VoteReset();
 437
 438         // clear overtime, we have to decrease timelimit to its original value again.
 439         if (checkrules_overtimesadded > 0 && g_race_qualifying != 2) { cvar_set("timelimit", ftos(autocvar_timelimit - (checkrules_overtimesadded * autocvar_timelimit_overtime))); }
 440
 441         checkrules_suddendeathend = checkrules_overtimesadded = checkrules_suddendeathwarning = 0;
 442
 443         readyrestart_happened = 1;
 444         game_starttime = time + RESTART_COUNTDOWN;
 445
 446         // clear player attributes
 447         FOR_EACH_CLIENT(tmp_player)
 448         {
 449                 tmp_player.alivetime = 0;
 450                 tmp_player.killcount = 0;
 451                 PS_GR_P_ADDVAL(tmp_player, PLAYERSTATS_ALIVETIME, -PS_GR_P_ADDVAL(tmp_player, PLAYERSTATS_ALIVETIME, 0));
 452         }
 453
 454         restart_mapalreadyrestarted = 0; // reset this var, needed when cvar sv_ready_restart_repeatable is in use
 455
 456         // disable the warmup global for the server
 457         warmup_stage = 0; // once the game is restarted the game is in match stage
 458
 459         // reset the .ready status of all players (also spectators)
 460         FOR_EACH_REALCLIENT(tmp_player) { tmp_player.ready = 0; }
 461         readycount = 0;
 462         Nagger_ReadyCounted(); // NOTE: this causes a resend of that entity, and will also turn off warmup state on the client
 463
 464         // lock teams with lockonrestart
 465         if(autocvar_teamplay_lockonrestart && teamplay)
 466         {
 467                 lockteams = 1;
 468                 bprint("^1The teams are now locked.\n");
 469         }
 470
 471         //initiate the restart-countdown-announcer entity
 472         if(autocvar_sv_ready_restart_after_countdown)
 473         {
 474                 restart_timer = spawn();
 475                 restart_timer.think = ReadyRestart_think;
 476                 restart_timer.nextthink = game_starttime;
 477         }
 478
 479         // after a restart every players number of allowed timeouts gets reset, too
 480         if(autocvar_sv_timeout) { FOR_EACH_REALPLAYER(tmp_player) { tmp_player.allowed_timeouts = autocvar_sv_timeout_number; } }
 481
 482         //reset map immediately if this cvar is not set
 483         if (!autocvar_sv_ready_restart_after_countdown) { reset_map(true); }
 484
 485         if(autocvar_sv_eventlog) { GameLogEcho(":restart"); }
 486 }
 487
 488 void ReadyRestart()
 489 {
 490         // no arena, assault support yet...
 491         if(g_assault | gameover | intermission_running | race_completing)
 492                 localcmd("restart\n");
 493         else
 494                 localcmd("\nsv_hook_gamerestart\n");
 495
 496         // Reset ALL scores, but only do that at the beginning of the countdown if sv_ready_restart_after_countdown is off!
 497         // Otherwise scores could be manipulated during the countdown.
 498         if (!autocvar_sv_ready_restart_after_countdown) { Score_ClearAll(); }
 499
 500         ReadyRestart_force();
 501
 502         return;
 503 }
 504
 505 // Count the players who are ready and determine whether or not to restart the match
 506 void ReadyCount()
 507 {
 508         entity tmp_player;
 509         float ready_needed_factor, ready_needed_count;
 510         float t_ready = 0, t_players = 0;
 511
 512         FOR_EACH_REALCLIENT(tmp_player)
 513         {
 514                 if(IS_PLAYER(tmp_player) || tmp_player.caplayer == 1)
 515                 {
 516                         ++t_players;
 517                         if(tmp_player.ready) { ++t_ready; }
 518                 }
 519         }
 520
 521         readycount = t_ready;
 522
 523         Nagger_ReadyCounted();
 524
 525         ready_needed_factor = bound(0.5, cvar("g_warmup_majority_factor"), 0.999);
 526         ready_needed_count = floor(t_players * ready_needed_factor) + 1;
 527
 528         if(readycount >= ready_needed_count)
 529         {
 530                 ReadyRestart();
 531         }
 532
 533         return;
 534 }
 535
 536
 537 // ======================================
 538 //  Supporting functions for VoteCommand
 539 // ======================================
 540
 541 float Votecommand_check_assignment(entity caller, float assignment)
 542 {
 543         float from_server = (!caller);
 544
 545         if((assignment == VC_ASGNMNT_BOTH)
 546                 || ((!from_server && assignment == VC_ASGNMNT_CLIENTONLY)
 547                 || (from_server && assignment == VC_ASGNMNT_SERVERONLY)))
 548         {
 549                 return true;
 550         }
 551
 552         return false;
 553 }
 554
 555 string VoteCommand_extractcommand(string input, float startpos, float argc)
 556 {
 557         string output;
 558
 559         if((argc - 1) < startpos)
 560                 output = "";
 561         else
 562                 output = substring(input, argv_start_index(startpos), argv_end_index(-1) - argv_start_index(startpos));
 563
 564         return output;
 565 }
 566
 567 float VoteCommand_checknasty(string vote_command)
 568 {
 569         if((strstrofs(vote_command, ";", 0) >= 0)
 570                 || (strstrofs(vote_command, "\n", 0) >= 0)
 571                 || (strstrofs(vote_command, "\r", 0) >= 0)
 572                 || (strstrofs(vote_command, "$", 0) >= 0))
 573                 return false;
 574
 575         return true;
 576 }
 577
 578 float VoteCommand_checkinlist(string vote_command, string list)
 579 {
 580         string l = strcat(" ", list, " ");
 581
 582         if(strstrofs(l, strcat(" ", vote_command, " "), 0) >= 0)
 583                 return true;
 584
 585         return false;
 586 }
 587
 588 string ValidateMap(string validated_map, entity caller)
 589 {
 590         validated_map = MapInfo_FixName(validated_map);
 591
 592         if (!validated_map)
 593         {
 594                 print_to(caller, "This map is not available on this server.");
 595                 return string_null;
 596         }
 597
 598         if(!autocvar_sv_vote_override_mostrecent && caller)
 599         {
 600                 if(Map_IsRecent(validated_map))
 601                 {
 602                         print_to(caller, "This server does not allow for recent maps to be played again. Please be patient for some rounds.");
 603                         return string_null;
 604                 }
 605         }
 606
 607         if(!MapInfo_CheckMap(validated_map))
 608         {
 609                 print_to(caller, strcat("^1Invalid mapname, \"^3", validated_map, "^1\" does not support the current game mode."));
 610                 return string_null;
 611         }
 612
 613         return validated_map;
 614 }
 615
 616 float VoteCommand_checkargs(float startpos, float argc)
 617 {
 618         float p, q, check, minargs;
 619         string cvarname = strcat("sv_vote_command_restriction_", argv(startpos));
 620         string cmdrestriction = cvar_string(cvarname); // note: this warns on undefined cvar. We want that.
 621         string charlist, arg;
 622         float checkmate;
 623
 624         if(cmdrestriction == "")
 625                 return true;
 626
 627         ++startpos; // skip command name
 628
 629         // check minimum arg count
 630
 631         // 0 args: argc == startpos
 632         // 1 args: argc == startpos + 1
 633         // ...
 634
 635         minargs = stof(cmdrestriction);
 636         if(argc - startpos < minargs)
 637                 return false;
 638
 639         p = strstrofs(cmdrestriction, ";", 0); // find first semicolon
 640
 641         for(0;;)
 642         {
 643                 // we know that at any time, startpos <= argc - minargs
 644                 // so this means: argc-minargs >= startpos >= argc, thus
 645                 // argc-minargs >= argc, thus minargs <= 0, thus all minargs
 646                 // have been seen already
 647
 648                 if(startpos >= argc) // all args checked? GOOD
 649                         break;
 650
 651                 if(p < 0) // no more args? FAIL
 652                 {
 653                         // exception: exactly minargs left, this one included
 654                         if(argc - startpos == minargs)
 655                                 break;
 656
 657                         // otherwise fail
 658                         return false;
 659                 }
 660
 661                 // cut to next semicolon
 662                 q = strstrofs(cmdrestriction, ";", p+1); // find next semicolon
 663                 if(q < 0)
 664                         charlist = substring(cmdrestriction, p+1, -1);
 665                 else
 666                         charlist = substring(cmdrestriction, p+1, q - (p+1));
 667
 668                 // in case we ever want to allow semicolons in VoteCommand_checknasty
 669                 // charlist = strreplace("^^", ";", charlist);
 670
 671                 if(charlist != "")
 672                 {
 673                         // verify the arg only contains allowed chars
 674                         arg = argv(startpos);
 675                         checkmate = strlen(arg);
 676                         for(check = 0; check < checkmate; ++check)
 677                                 if(strstrofs(charlist, substring(arg, check, 1), 0) < 0)
 678                                         return false; // not allowed character
 679                         // all characters are allowed. FINE.
 680                 }
 681
 682                 ++startpos;
 683                 --minargs;
 684                 p = q;
 685         }
 686
 687         return true;
 688 }
 689
 690 float VoteCommand_parse(entity caller, string vote_command, string vote_list, float startpos, float argc)
 691 {
 692         string first_command;
 693
 694         first_command = argv(startpos);
 695
 696         /*printf("VoteCommand_parse(): Command: '%s', Length: %f.\n",
 697                 substring(vote_command, argv_start_index(startpos), strlen(vote_command) - argv_start_index(startpos)),
 698                 strlen(substring(vote_command, argv_start_index(startpos), strlen(vote_command) - argv_start_index(startpos)))
 699         );*/
 700
 701         if(
 702                 (autocvar_sv_vote_limit > 0)
 703                 &&
 704                 (strlen(substring(vote_command, argv_start_index(startpos), strlen(vote_command) - argv_start_index(startpos))) > autocvar_sv_vote_limit)
 705         )
 706                 return false;
 707
 708         if (!VoteCommand_checkinlist(first_command, vote_list))
 709                 return false;
 710
 711         if (!VoteCommand_checkargs(startpos, argc))
 712                 return false;
 713
 714         switch(first_command) // now go through and parse the proper commands to adjust as needed.
 715         {
 716                 case "kick":
 717                 case "kickban": // catch all kick/kickban commands
 718                 {
 719                         entity victim = GetIndexedEntity(argc, (startpos + 1));
 720                         float accepted = VerifyClientEntity(victim, true, false);
 721
 722                         if(accepted > 0)
 723                         {
 724                                 string reason = ((argc > next_token) ? substring(vote_command, argv_start_index(next_token), strlen(vote_command) - argv_start_index(next_token)) : "No reason provided");
 725                                 string command_arguments;
 726
 727                                 if(first_command == "kickban")
 728                                         command_arguments = strcat(ftos(autocvar_g_ban_default_bantime), " ", ftos(autocvar_g_ban_default_masksize), " ~");
 729                                 else
 730                                         command_arguments = reason;
 731
 732                                 vote_parsed_command = strcat(first_command, " # ", ftos(num_for_edict(victim)), " ", command_arguments);
 733                                 vote_parsed_display = strcat("^1", vote_command, " (^7", victim.netname, "^1): ", reason);
 734                         }
 735                         else { print_to(caller, strcat("vcall: ", GetClientErrorString(accepted, argv(startpos + 1)), ".\n")); return false; }
 736
 737                         break;
 738                 }
 739
 740                 case "map":
 741                 case "chmap":
 742                 case "gotomap": // re-direct all map selection commands to gotomap
 743                 {
 744                         vote_command = ValidateMap(argv(startpos + 1), caller);
 745                         if (!vote_command) { return false; }
 746                         vote_parsed_command = strcat("gotomap ", vote_command);
 747                         vote_parsed_display = strzone(strcat("^1", vote_parsed_command));
 748
 749                         break;
 750                 }
 751
 752                 default:
 753                 {
 754                         vote_parsed_command = vote_command;
 755                         vote_parsed_display = strzone(strcat("^1", vote_command));
 756
 757                         break;
 758                 }
 759         }
 760
 761         return true;
 762 }
 763
 764
 765 // =======================
 766 //  Command Sub-Functions
 767 // =======================
 768
 769 void VoteCommand_abstain(float request, entity caller) // CLIENT ONLY
 770 {
 771         switch(request)
 772         {
 773                 case CMD_REQUEST_COMMAND:
 774                 {
 775                         if (!vote_called) { print_to(caller, "^1No vote called."); }
 776                         else if(caller.vote_selection != VOTE_SELECT_NULL && !autocvar_sv_vote_change) { print_to(caller, "^1You have already voted."); }
 777
 778                         else // everything went okay, continue changing vote
 779                         {
 780                                 print_to(caller, "^1You abstained from your vote.");
 781                                 caller.vote_selection = VOTE_SELECT_ABSTAIN;
 782                                 msg_entity = caller;
 783                                 if(!autocvar_sv_vote_singlecount) { VoteCount(false); }
 784                         }
 785
 786                         return;
 787                 }
 788
 789                 default:
 790                 case CMD_REQUEST_USAGE:
 791                 {
 792                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " vote abstain"));
 793                         print_to(caller, "  No arguments required.");
 794                         return;
 795                 }
 796         }
 797 }
 798
 799 void VoteCommand_call(float request, entity caller, float argc, string vote_command) // BOTH
 800 {
 801         switch(request)
 802         {
 803                 case CMD_REQUEST_COMMAND:
 804                 {
 805                         float spectators_allowed = ((autocvar_sv_vote_nospectators != 2)
 806                                 || ((autocvar_sv_vote_nospectators == 1) && warmup_stage)
 807                                 || (autocvar_sv_vote_nospectators == 0));
 808
 809                         float tmp_playercount = 0;
 810                         entity tmp_player;
 811
 812                         vote_command = VoteCommand_extractcommand(vote_command, 2, argc);
 813
 814                         if(!autocvar_sv_vote_call && caller) { print_to(caller, "^1Vote calling is not allowed."); }
 815                         else if(!autocvar_sv_vote_gamestart && time < game_starttime) { print_to(caller, "^1Vote calling is not allowed before the match has started."); }
 816                         else if(vote_called) { print_to(caller, "^1There is already a vote called."); }
 817                         else if(!spectators_allowed && (caller && !IS_PLAYER(caller))) { print_to(caller, "^1Only players can call a vote."); }
 818                         else if(timeout_status) { print_to(caller, "^1You can not call a vote while a timeout is active."); }
 819                         else if(caller && (time < caller.vote_waittime)) { print_to(caller, strcat("^1You have to wait ^2", ftos(ceil(caller.vote_waittime - time)), "^1 seconds before you can again call a vote.")); }
 820                         else if (!VoteCommand_checknasty(vote_command)) { print_to(caller, "^1Syntax error in command, see 'vhelp' for more info."); }
 821                         else if (!VoteCommand_parse(caller, vote_command, autocvar_sv_vote_commands, 2, argc)) { print_to(caller, "^1This command is not acceptable, see 'vhelp' for more info."); }
 822
 823                         else // everything went okay, continue with calling the vote
 824                         {
 825                                 vote_caller = caller; // remember who called the vote
 826                                 vote_called = VOTE_NORMAL;
 827                                 vote_called_command = strzone(vote_parsed_command);
 828                                 vote_called_display = strzone(vote_parsed_display);
 829                                 vote_endtime = time + autocvar_sv_vote_timeout;
 830
 831                                 if(caller)
 832                                 {
 833                                         caller.vote_selection = VOTE_SELECT_ACCEPT;
 834                                         caller.vote_waittime = time + autocvar_sv_vote_wait;
 835                                         msg_entity = caller;
 836                                 }
 837
 838                                 FOR_EACH_REALCLIENT(tmp_player) { ++tmp_playercount; }
 839                                 if(tmp_playercount > 1) { Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_VOTE_CALL); } // don't announce a "vote now" sound if player is alone
 840
 841                                 bprint("\{1}^2* ^3", GetCallerName(vote_caller), "^2 calls a vote for ", vote_called_display, "\n");
 842                                 if(autocvar_sv_eventlog) { GameLogEcho(strcat(":vote:vcall:", ftos(vote_caller.playerid), ":", vote_called_display)); }
 843                                 Nagger_VoteChanged();
 844                                 VoteCount(true); // needed if you are the only one
 845                         }
 846
 847                         return;
 848                 }
 849
 850                 default:
 851                 case CMD_REQUEST_USAGE:
 852                 {
 853                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " vote call command"));
 854                         print_to(caller, "  Where 'command' is the command to request a vote upon.");
 855                         print_to(caller, strcat("Examples: ", GetCommandPrefix(caller), " vote call gotomap dance"));
 856                         print_to(caller, strcat("          ", GetCommandPrefix(caller), " vote call endmatch"));
 857                         return;
 858                 }
 859         }
 860 }
 861
 862 void VoteCommand_master(float request, entity caller, float argc, string vote_command) // CLIENT ONLY
 863 {
 864         switch(request)
 865         {
 866                 case CMD_REQUEST_COMMAND:
 867                 {
 868                         if(autocvar_sv_vote_master)
 869                         {
 870                                 switch(strtolower(argv(2)))
 871                                 {
 872                                         case "do":
 873                                         {
 874                                                 vote_command = VoteCommand_extractcommand(vote_command, 3, argc);
 875
 876                                                 if (!caller.vote_master) { print_to(caller, "^1You do not have vote master privelages."); }
 877                                                 else if (!VoteCommand_checknasty(vote_command)) { print_to(caller, "^1Syntax error in command, see 'vhelp' for more info."); }
 878                                                 else if (!VoteCommand_parse(caller, vote_command, strcat(autocvar_sv_vote_commands, " ", autocvar_sv_vote_master_commands), 3, argc)) { print_to(caller, "^1This command is not acceptable, see 'vhelp' for more info."); }
 879
 880                                                 else // everything went okay, proceed with command
 881                                                 {
 882                                                         localcmd(strcat(vote_parsed_command, "\n"));
 883                                                         print_to(caller, strcat("Executing command '", vote_parsed_display, "' on server."));
 884                                                         bprint("\{1}^2* ^3", GetCallerName(caller), "^2 used their ^3master^2 status to do \"^2", vote_parsed_display, "^2\".\n");
 885                                                         if(autocvar_sv_eventlog) { GameLogEcho(strcat(":vote:vdo:", ftos(caller.playerid), ":", vote_parsed_display)); }
 886                                                 }
 887
 888                                                 return;
 889                                         }
 890
 891                                         case "login":
 892                                         {
 893                                                 if(autocvar_sv_vote_master_password == "") { print_to(caller, "^1Login to vote master is not allowed."); }
 894                                                 else if(caller.vote_master) { print_to(caller, "^1You are already logged in as vote master."); }
 895                                                 else if(autocvar_sv_vote_master_password != argv(3)) { print_to(caller, strcat("Rejected vote master login from ", GetCallerName(caller))); }
 896
 897                                                 else // everything went okay, proceed with giving this player master privilages
 898                                                 {
 899                                                         caller.vote_master = true;
 900                                                         print_to(caller, strcat("Accepted vote master login from ", GetCallerName(caller)));
 901                                                         bprint("\{1}^2* ^3", GetCallerName(caller), "^2 logged in as ^3master^2\n");
 902                                                         if(autocvar_sv_eventlog) { GameLogEcho(strcat(":vote:vlogin:", ftos(caller.playerid))); }
 903                                                 }
 904
 905                                                 return;
 906                                         }
 907
 908                                         default: // calling a vote for master
 909                                         {
 910                                                 float spectators_allowed = ((autocvar_sv_vote_nospectators != 2)
 911                                                         || ((autocvar_sv_vote_nospectators == 1) && warmup_stage)
 912                                                         || (autocvar_sv_vote_nospectators == 0));
 913
 914                                                 if (!autocvar_sv_vote_master_callable) { print_to(caller, "^1Vote to become vote master is not allowed."); }
 915                                                 else if(vote_called) { print_to(caller, "^1There is already a vote called."); }
 916                                                 else if(!spectators_allowed && (caller && !IS_PLAYER(caller))) { print_to(caller, "^1Only players can call a vote."); }
 917                                                 else if(timeout_status) { print_to(caller, "^1You can not call a vote while a timeout is active."); }
 918
 919                                                 else // everything went okay, continue with creating vote
 920                                                 {
 921                                                         vote_caller = caller;
 922                                                         vote_called = VOTE_MASTER;
 923                                                         vote_called_command = strzone("XXX");
 924                                                         vote_called_display = strzone("^3master");
 925                                                         vote_endtime = time + autocvar_sv_vote_timeout;
 926
 927                                                         caller.vote_selection = VOTE_SELECT_ACCEPT;
 928                                                         caller.vote_waittime = time + autocvar_sv_vote_wait;
 929
 930                                                         bprint("\{1}^2* ^3", GetCallerName(vote_caller), "^2 calls a vote to become ^3master^2.\n");
 931                                                         if(autocvar_sv_eventlog) { GameLogEcho(strcat(":vote:vcall:", ftos(vote_caller.playerid), ":", vote_called_display)); }
 932                                                         Nagger_VoteChanged();
 933                                                         VoteCount(true); // needed if you are the only one
 934                                                 }
 935
 936                                                 return;
 937                                         }
 938                                 }
 939                         }
 940                         else { print_to(caller, "^1Master control of voting is not allowed."); }
 941
 942                         return;
 943                 }
 944
 945                 default:
 946                 case CMD_REQUEST_USAGE:
 947                 {
 948                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " vote master [action [command | password]]"));
 949                         print_to(caller, "  If action is left blank, it calls a vote for you to become master.");
 950                         print_to(caller, "  Otherwise the actions are either 'do' a command or 'login' as master.");
 951                         return;
 952                 }
 953         }
 954 }
 955
 956 void VoteCommand_no(float request, entity caller) // CLIENT ONLY
 957 {
 958         switch(request)
 959         {
 960                 case CMD_REQUEST_COMMAND:
 961                 {
 962                         if (!vote_called) { print_to(caller, "^1No vote called."); }
 963                         else if(caller.vote_selection != VOTE_SELECT_NULL && !autocvar_sv_vote_change) { print_to(caller, "^1You have already voted."); }
 964                         else if(((caller == vote_caller) || caller.vote_master) && autocvar_sv_vote_no_stops_vote) { VoteStop(caller); }
 965
 966                         else // everything went okay, continue changing vote
 967                         {
 968                                 print_to(caller, "^1You rejected the vote.");
 969                                 caller.vote_selection = VOTE_SELECT_REJECT;
 970                                 msg_entity = caller;
 971                                 if(!autocvar_sv_vote_singlecount) { VoteCount(false); }
 972                         }
 973
 974                         return;
 975                 }
 976
 977                 default:
 978                 case CMD_REQUEST_USAGE:
 979                 {
 980                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " vote no"));
 981                         print_to(caller, "  No arguments required.");
 982                         return;
 983                 }
 984         }
 985 }
 986
 987 void VoteCommand_status(float request, entity caller) // BOTH
 988 {
 989         switch(request)
 990         {
 991                 case CMD_REQUEST_COMMAND:
 992                 {
 993                         if(vote_called)
 994                                 print_to(caller, strcat("^7Vote for ", vote_called_display, "^7 called by ^7", GetCallerName(vote_caller), "^7."));
 995                         else
 996                                 print_to(caller, "^1No vote called.");
 997
 998                         return;
 999                 }
1000
1001                 default:
1002                 case CMD_REQUEST_USAGE:
1003                 {
1004                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " vote status"));
1005                         print_to(caller, "  No arguments required.");
1006                         return;
1007                 }
1008         }
1009 }
1010
1011 void VoteCommand_stop(float request, entity caller) // BOTH
1012 {
1013         switch(request)
1014         {
1015                 case CMD_REQUEST_COMMAND:
1016                 {
1017                         if (!vote_called) { print_to(caller, "^1No vote called."); }
1018                         else if((caller == vote_caller) || !caller || caller.vote_master) { VoteStop(caller); }
1019                         else { print_to(caller, "^1You are not allowed to stop that vote."); }
1020
1021                         return;
1022                 }
1023
1024                 default:
1025                 case CMD_REQUEST_USAGE:
1026                 {
1027                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " vote stop"));
1028                         print_to(caller, "  No arguments required.");
1029                         return;
1030                 }
1031         }
1032 }
1033
1034 void VoteCommand_yes(float request, entity caller) // CLIENT ONLY
1035 {
1036         switch(request)
1037         {
1038                 case CMD_REQUEST_COMMAND:
1039                 {
1040                         if (!vote_called) { print_to(caller, "^1No vote called."); }
1041                         else if(caller.vote_selection != VOTE_SELECT_NULL && !autocvar_sv_vote_change) { print_to(caller, "^1You have already voted."); }
1042
1043                         else // everything went okay, continue changing vote
1044                         {
1045                                 print_to(caller, "^1You accepted the vote.");
1046                                 caller.vote_selection = VOTE_SELECT_ACCEPT;
1047                                 msg_entity = caller;
1048                                 if(!autocvar_sv_vote_singlecount) { VoteCount(false); }
1049                         }
1050
1051                         return;
1052                 }
1053
1054                 default:
1055                 case CMD_REQUEST_USAGE:
1056                 {
1057                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " vote yes"));
1058                         print_to(caller, "  No arguments required.");
1059                         return;
1060                 }
1061         }
1062 }
1063
1064 /* use this when creating a new command, making sure to place it in alphabetical order... also,
1065 ** ADD ALL NEW COMMANDS TO commands.cfg WITH PROPER ALIASES IN THE SAME FASHION!
1066 void VoteCommand_(float request)
1067 {
1068         switch(request)
1069         {
1070                 case CMD_REQUEST_COMMAND:
1071                 {
1072
1073                         return;
1074                 }
1075
1076                 default:
1077                 case CMD_REQUEST_USAGE:
1078                 {
1079                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " vote ");
1080                         print_to(caller, "  No arguments required.");
1081                         return;
1082                 }
1083         }
1084 }
1085 */
1086
1087
1088 // ================================
1089 //  Macro system for vote commands
1090 // ================================
1091
1092 // Do not hard code aliases for these, instead create them in commands.cfg... also: keep in alphabetical order, please ;)
1093 #define VOTE_COMMANDS(request,caller,arguments,command) \
1094         VOTE_COMMAND("abstain", VoteCommand_abstain(request, caller), "Abstain your vote in current vote", VC_ASGNMNT_CLIENTONLY) \
1095         VOTE_COMMAND("call", VoteCommand_call(request, caller, arguments, command), "Create a new vote for players to decide on", VC_ASGNMNT_BOTH) \
1096         VOTE_COMMAND("help", VoteCommand_macro_help(caller, arguments), "Shows this information", VC_ASGNMNT_BOTH) \
1097         VOTE_COMMAND("master", VoteCommand_master(request, caller, arguments, command), "Full control over all voting and vote commands", VC_ASGNMNT_CLIENTONLY) \
1098         VOTE_COMMAND("no", VoteCommand_no(request, caller), "Select no in current vote", VC_ASGNMNT_CLIENTONLY) \
1099         VOTE_COMMAND("status", VoteCommand_status(request, caller), "Prints information about current vote", VC_ASGNMNT_BOTH) \
1100         VOTE_COMMAND("stop", VoteCommand_stop(request, caller), "Immediately end a vote", VC_ASGNMNT_BOTH) \
1101         VOTE_COMMAND("yes", VoteCommand_yes(request, caller), "Select yes in current vote", VC_ASGNMNT_CLIENTONLY) \
1102         /* nothing */
1103
1104 void VoteCommand_macro_help(entity caller, float argc)
1105 {
1106         string command_origin = GetCommandPrefix(caller);
1107
1108         if(argc == 2 || argv(2) == "help") // help display listing all commands
1109         {
1110                 print_to(caller, "\nVoting commands:\n");
1111                 #define VOTE_COMMAND(name,function,description,assignment) \
1112                         { if(Votecommand_check_assignment(caller, assignment)) { print_to(caller, strcat("  ^2", name, "^7: ", description)); } }
1113
1114                 VOTE_COMMANDS(0, caller, 0, "");
1115                 #undef VOTE_COMMAND
1116
1117                 print_to(caller, strcat("\nUsage:^3 ", command_origin, " vote COMMAND...^7, where possible commands are listed above.\n"));
1118                 print_to(caller, strcat("For help about a specific command, type ", command_origin, " vote help COMMAND"));
1119                 print_to(caller, strcat("\n^7You can call a vote for or execute these commands: ^3", autocvar_sv_vote_commands, "^7 and maybe further ^3arguments^7"));
1120         }
1121         else // usage for individual command
1122         {
1123                 #define VOTE_COMMAND(name,function,description,assignment) \
1124                         { if(Votecommand_check_assignment(caller, assignment)) { if(name == strtolower(argv(2))) { function; return; } } }
1125
1126                 VOTE_COMMANDS(CMD_REQUEST_USAGE, caller, argc, "");
1127                 #undef VOTE_COMMAND
1128         }
1129
1130         return;
1131 }
1132
1133 float VoteCommand_macro_command(entity caller, float argc, string vote_command)
1134 {
1135         #define VOTE_COMMAND(name,function,description,assignment) \
1136                 { if(Votecommand_check_assignment(caller, assignment)) { if(name == strtolower(argv(1))) { function; return true; } } }
1137
1138         VOTE_COMMANDS(CMD_REQUEST_COMMAND, caller, argc, vote_command);
1139         #undef VOTE_COMMAND
1140
1141         return false;
1142 }
1143
1144
1145 // ======================================
1146 //  Main function handling vote commands
1147 // ======================================
1148
1149 void VoteCommand(float request, entity caller, float argc, string vote_command)
1150 {
1151         // Guide for working with argc arguments by example:
1152         // argc:   1    - 2      - 3     - 4
1153         // argv:   0    - 1      - 2     - 3
1154         // cmd     vote - master - login - password
1155
1156         switch(request)
1157         {
1158                 case CMD_REQUEST_COMMAND:
1159                 {
1160                         if(VoteCommand_macro_command(caller, argc, vote_command))
1161                                 return;
1162                 }
1163
1164                 default:
1165                         print_to(caller, strcat(((argv(1) != "") ? strcat("Unknown vote command \"", argv(1), "\"") : "No command provided"), ". For a list of supported commands, try ", GetCommandPrefix(caller), " vote help.\n"));
1166                 case CMD_REQUEST_USAGE:
1167                 {
1168                         VoteCommand_macro_help(caller, argc);
1169                         return;
1170                 }
1171         }
1172 }