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