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