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