8fd5fb047f083d41e7fbf676b53cbaf20931c121
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / command / common.qc
1 #include "../../common/command/command.qh"
2 #include "common.qh"
3
4 #include "../scores.qh"
5
6 #include "../../common/monsters/all.qh"
7 #include "../../common/notifications.qh"
8 #include "../../lib/warpzone/common.qh"
9
10
11 // ====================================================
12 //  Shared code for server commands, written by Samual
13 //  Last updated: December 27th, 2011
14 // ====================================================
15
16 // select the proper prefix for usage and other messages
17 string GetCommandPrefix(entity caller)
18 {
19         if (caller) return "cmd";
20         else return "sv_cmd";
21 }
22
23 // if client return player nickname, or if server return admin nickname
24 string GetCallerName(entity caller)
25 {
26         if (caller) return caller.netname;
27         else return admin_name();  // ((autocvar_sv_adminnick != "") ? autocvar_sv_adminnick : autocvar_hostname);
28 }
29
30 // verify that the client provided is acceptable for kicking
31 float VerifyKickableEntity(entity client)
32 {
33         if (!IS_REAL_CLIENT(client)) return CLIENT_NOT_REAL;
34         return CLIENT_ACCEPTABLE;
35 }
36
37 // verify that the client provided is acceptable for use
38 float VerifyClientEntity(entity client, float must_be_real, float must_be_bots)
39 {
40         if (!IS_CLIENT(client)) return CLIENT_DOESNT_EXIST;
41         else if (must_be_real && !IS_REAL_CLIENT(client)) return CLIENT_NOT_REAL;
42         else if (must_be_bots && !IS_BOT_CLIENT(client)) return CLIENT_NOT_BOT;
43
44         return CLIENT_ACCEPTABLE;
45 }
46
47 // if the client is not acceptable, return a string to be used for error messages
48 string GetClientErrorString_color(float clienterror, string original_input, string col)
49 {
50         switch (clienterror)
51         {
52                 case CLIENT_DOESNT_EXIST:
53                 { return strcat(col, "Client '", original_input, col, "' doesn't exist");
54                 }
55                 case CLIENT_NOT_REAL:
56                 { return strcat(col, "Client '", original_input, col, "' is not real");
57                 }
58                 case CLIENT_NOT_BOT:
59                 { return strcat(col, "Client '", original_input, col, "' is not a bot");
60                 }
61                 default:
62                 { return "Incorrect usage of GetClientErrorString";
63                 }
64         }
65 }
66
67 // is this entity number even in the possible range of entities?
68 float VerifyClientNumber(float tmp_number)
69 {
70         if ((tmp_number < 1) || (tmp_number > maxclients)) return false;
71         else return true;
72 }
73
74 entity GetIndexedEntity(float argc, float start_index)
75 {
76         entity selection;
77         float tmp_number, index;
78         string tmp_string;
79
80         next_token = -1;
81         index = start_index;
82         selection = world;
83
84         if (argc > start_index)
85         {
86                 if (substring(argv(index), 0, 1) == "#")
87                 {
88                         tmp_string = substring(argv(index), 1, -1);
89                         ++index;
90
91                         if (tmp_string != "")  // is it all one token? like #1
92                         {
93                                 tmp_number = stof(tmp_string);
94                         }
95                         else if (argc > index)  // no, it's two tokens? # 1
96                         {
97                                 tmp_number = stof(argv(index));
98                                 ++index;
99                         }
100                         else
101                         {
102                                 tmp_number = 0;
103                         }
104                 }
105                 else  // maybe it's ONLY a number?
106                 {
107                         tmp_number = stof(argv(index));
108                         ++index;
109                 }
110
111                 if (VerifyClientNumber(tmp_number))
112                 {
113                         selection = edict_num(tmp_number);  // yes, it was a number
114                 }
115                 else  // no, maybe it's a name?
116                 {
117                         FOREACH_CLIENT(true, LAMBDA(
118                                 if(strdecolorize(it.netname) == strdecolorize(argv(start_index)))
119                                 {
120                                         selection = it;
121                                         break; // no reason to keep looking
122                                 }
123                         ));
124
125                         index = (start_index + 1);
126                 }
127         }
128
129         next_token = index;
130         // print(strcat("start_index: ", ftos(start_index), ", next_token: ", ftos(next_token), ", edict: ", ftos(num_for_edict(selection)), ".\n"));
131         return selection;
132 }
133
134 // find a player which matches the input string, and return their entity
135 entity GetFilteredEntity(string input)
136 {
137         entity selection;
138         float tmp_number;
139
140         if (substring(input, 0, 1) == "#") tmp_number = stof(substring(input, 1, -1));
141         else tmp_number = stof(input);
142
143         if (VerifyClientNumber(tmp_number))
144         {
145                 selection = edict_num(tmp_number);
146         }
147         else
148         {
149                 selection = world;
150                 FOREACH_CLIENT(true, LAMBDA(
151                         if(strdecolorize(it.netname) == strdecolorize(input))
152                         {
153                                 selection = it;
154                                 break; // no reason to keep looking
155                         }
156                 ));
157         }
158
159         return selection;
160 }
161
162 // same thing, but instead return their edict number
163 float GetFilteredNumber(string input)
164 {
165         entity selection = GetFilteredEntity(input);
166         float output;
167
168         output = etof(selection);
169
170         return output;
171 }
172
173 // switch between sprint and print depending on whether the receiver is the server or a player
174 void print_to(entity to, string input)
175 {
176         if (to) sprint(to, strcat(input, "\n"));
177         else LOG_INFO(input, "\n");
178 }
179
180 // ==========================================
181 //  Supporting functions for common commands
182 // ==========================================
183
184 // used by CommonCommand_timeout() and CommonCommand_timein() to handle game pausing and messaging and such.
185 void timeout_handler_reset()
186 {
187         SELFPARAM();
188         timeout_caller = world;
189         timeout_time = 0;
190         timeout_leadtime = 0;
191
192         remove(self);
193 }
194
195 void timeout_handler_think()
196 {
197         SELFPARAM();
198         switch (timeout_status)
199         {
200                 case TIMEOUT_ACTIVE:
201                 {
202                         if (timeout_time > 0)  // countdown is still going
203                         {
204                                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_TIMEOUT_ENDING, timeout_time);
205
206                                 if (timeout_time == autocvar_sv_timeout_resumetime) // play a warning sound when only <sv_timeout_resumetime> seconds are left
207                                         Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_PREPARE);
208
209                                 self.nextthink = time + TIMEOUT_SLOWMO_VALUE;       // think again in one second
210                                 timeout_time -= 1;                                  // decrease the time counter
211                         }
212                         else  // time to end the timeout
213                         {
214                                 timeout_status = TIMEOUT_INACTIVE;
215
216                                 // reset the slowmo value back to normal
217                                 cvar_set("slowmo", ftos(orig_slowmo));
218
219                                 // unlock the view for players so they can move around again
220                                 FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), LAMBDA(
221                                         it.fixangle = false;
222                                 ));
223
224                                 timeout_handler_reset();
225                         }
226
227                         return;
228                 }
229
230                 case TIMEOUT_LEADTIME:
231                 {
232                         if (timeout_leadtime > 0)  // countdown is still going
233                         {
234                                 Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_TIMEOUT_BEGINNING, timeout_leadtime);
235
236                                 self.nextthink = time + 1; // think again in one second
237                                 timeout_leadtime -= 1;     // decrease the time counter
238                         }
239                         else  // time to begin the timeout
240                         {
241                                 timeout_status = TIMEOUT_ACTIVE;
242
243                                 // set the slowmo value to the timeout default slowmo value
244                                 cvar_set("slowmo", ftos(TIMEOUT_SLOWMO_VALUE));
245
246                                 // reset all the flood variables
247                                 FOREACH_CLIENT(true, LAMBDA(
248                                         it.nickspamcount = it.nickspamtime = it.floodcontrol_chat =
249                                                 it.floodcontrol_chatteam = it.floodcontrol_chattell =
250                                                         it.floodcontrol_voice = it.floodcontrol_voiceteam = 0;
251                                 ));
252
253                                 // copy .v_angle to .lastV_angle for every player in order to fix their view during pause (see PlayerPreThink)
254                                 FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), LAMBDA(
255                                         it.lastV_angle = it.v_angle;
256                                 ));
257
258                                 self.nextthink = time;  // think again next frame to handle it under TIMEOUT_ACTIVE code
259                         }
260
261                         return;
262                 }
263
264
265                 case TIMEOUT_INACTIVE:
266                 default:
267                 {
268                         timeout_handler_reset();
269                         return;
270                 }
271         }
272 }
273
274
275 // ===================================================
276 //  Common commands used in both sv_cmd.qc and cmd.qc
277 // ===================================================
278
279 void CommonCommand_cvar_changes(float request, entity caller)
280 {
281         switch (request)
282         {
283                 case CMD_REQUEST_COMMAND:
284                 {
285                         print_to(caller, cvar_changes);
286                         return;  // never fall through to usage
287                 }
288
289                 default:
290                 case CMD_REQUEST_USAGE:
291                 {
292                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " cvar_changes"));
293                         print_to(caller, "  No arguments required.");
294                         print_to(caller, "See also: ^2cvar_purechanges^7");
295                         return;
296                 }
297         }
298 }
299
300 void CommonCommand_cvar_purechanges(float request, entity caller)
301 {
302         switch (request)
303         {
304                 case CMD_REQUEST_COMMAND:
305                 {
306                         print_to(caller, cvar_purechanges);
307                         return;  // never fall through to usage
308                 }
309
310                 default:
311                 case CMD_REQUEST_USAGE:
312                 {
313                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " cvar_purechanges"));
314                         print_to(caller, "  No arguments required.");
315                         print_to(caller, "See also: ^2cvar_changes^7");
316                         return;
317                 }
318         }
319 }
320
321 void CommonCommand_editmob(int request, entity caller, int argc)
322 {
323         SELFPARAM();
324         switch (request)
325         {
326                 case CMD_REQUEST_COMMAND:
327                 {
328                         if (autocvar_g_campaign) { print_to(caller, "Monster editing is disabled in singleplayer"); return; }
329                         // no checks for g_monsters here, as it may be toggled mid match which existing monsters
330
331                         if (caller)
332                         {
333                                 makevectors(self.v_angle);
334                                 WarpZone_TraceLine(self.origin + self.view_ofs, self.origin + self.view_ofs + v_forward * 100, MOVE_NORMAL, self);
335                         }
336
337                         entity mon = trace_ent;
338                         bool is_visible = IS_MONSTER(mon);
339                         string argument = argv(2);
340
341                         switch (argv(1))
342                         {
343                                 case "name":
344                                 {
345                                         if (!caller) { print_to(caller, "Only players can edit monsters"); return; }
346                                         if (!argument)   break;  // escape to usage
347                                         if (!autocvar_g_monsters_edit) { print_to(caller, "Monster editing is disabled"); return; }
348                                         if (mon.realowner != caller && autocvar_g_monsters_edit < 2) { print_to(caller, "This monster does not belong to you"); return; }
349                                         if (!is_visible) { print_to(caller, "You must look at your monster to edit it"); return; }
350
351                                         string mon_oldname = mon.monster_name;
352
353                                         mon.monster_name = argument;
354                                         if (mon.sprite)   WaypointSprite_UpdateSprites(mon.sprite, WP_Monster, WP_Null, WP_Null);
355                                         print_to(caller, sprintf("Your pet '%s' is now known as '%s'", mon_oldname, mon.monster_name));
356                                         return;
357                                 }
358                                 case "spawn":
359                                 {
360                                         if (!caller) { print_to(caller, "Only players can spawn monsters"); return; }
361                                         if (!argv(2))   break;  // escape to usage
362
363                                         int moveflag, tmp_moncount = 0;
364                                         string arg_lower = strtolower(argument);
365                                         moveflag = (argv(3)) ? stof(argv(3)) : 1;  // follow owner if not defined
366                                         ret_string = "Monster spawning is currently disabled by a mutator";
367
368                                         if (arg_lower == "list") { print_to(caller, monsterlist_reply); return; }
369
370                                         FOREACH_ENTITY_FLAGS(flags, FL_MONSTER, LAMBDA(
371                                                 if(it.realowner == caller)
372                                                         ++tmp_moncount;
373                                         ));
374
375                                         if (!autocvar_g_monsters) { print_to(caller, "Monsters are disabled"); return; }
376                                         if (autocvar_g_monsters_max <= 0 || autocvar_g_monsters_max_perplayer <= 0) { print_to(caller, "Monster spawning is disabled"); return; }
377                                         if (!IS_PLAYER(caller)) { print_to(caller, "You must be playing to spawn a monster"); return; }
378                                         if (MUTATOR_CALLHOOK(AllowMobSpawning)) { print_to(caller, ret_string); return; }
379                                         if (caller.vehicle) { print_to(caller, "You can't spawn monsters while driving a vehicle"); return; }
380                                         if (caller.frozen) { print_to(caller, "You can't spawn monsters while frozen"); return; }
381                                         if (caller.deadflag != DEAD_NO) { print_to(caller, "You can't spawn monsters while dead"); return; }
382                                         if (tmp_moncount >= autocvar_g_monsters_max) { print_to(caller, "The maximum monster count has been reached"); return; }
383                                         if (tmp_moncount >= autocvar_g_monsters_max_perplayer) { print_to(caller, "You can't spawn any more monsters"); return; }
384
385                                         bool found = false;
386                                         for (int i = MON_FIRST; i <= MON_LAST; ++i)
387                                         {
388                                                 mon = get_monsterinfo(i);
389                                                 if (mon.netname == arg_lower) { found = true; break; }
390                                         }
391
392                                         if (!found && arg_lower != "random") { print_to(caller, "Invalid monster"); return; }
393
394                                         totalspawned += 1;
395                                         WarpZone_TraceBox(CENTER_OR_VIEWOFS(caller), caller.mins, caller.maxs, CENTER_OR_VIEWOFS(caller) + v_forward * 150, true, caller);
396                                         mon = spawnmonster(arg_lower, 0, caller, caller, trace_endpos, false, false, moveflag);
397                                         print_to(caller, strcat("Spawned ", mon.monster_name));
398                                         return;
399                                 }
400                                 case "kill":
401                                 {
402                                         if (!caller) { print_to(caller, "Only players can kill monsters"); return; }
403                                         if (mon.realowner != caller && autocvar_g_monsters_edit < 2) { print_to(caller, "This monster does not belong to you"); return; }
404                                         if (!is_visible) { print_to(caller, "You must look at your monster to edit it"); return; }
405
406                                         Damage(mon, world, world, mon.health + mon.max_health + 200, DEATH_KILL.m_id, mon.origin, '0 0 0');
407                                         print_to(caller, strcat("Your pet '", mon.monster_name, "' has been brutally mutilated"));
408                                         return;
409                                 }
410                                 case "skin":
411                                 {
412                                         if (!caller) { print_to(caller, "Only players can edit monsters"); return; }
413                                         if (!argument)   break;  // escape to usage
414                                         if (!autocvar_g_monsters_edit) { print_to(caller, "Monster editing is disabled"); return; }
415                                         if (!is_visible) { print_to(caller, "You must look at your monster to edit it"); return; }
416                                         if (mon.realowner != caller && autocvar_g_monsters_edit < 2) { print_to(caller, "This monster does not belong to you"); return; }
417                                         if (mon.monsterid == MON_MAGE.monsterid) { print_to(caller, "Mage skins can't be changed"); return; }  // TODO
418
419                                         mon.skin = stof(argument);
420                                         print_to(caller, strcat("Monster skin successfully changed to ", ftos(mon.skin)));
421                                         return;
422                                 }
423                                 case "movetarget":
424                                 {
425                                         if (!caller) { print_to(caller, "Only players can edit monsters"); return; }
426                                         if (!argument)   break;  // escape to usage
427                                         if (!autocvar_g_monsters_edit) { print_to(caller, "Monster editing is disabled"); return; }
428                                         if (!is_visible) { print_to(caller, "You must look at your monster to edit it"); return; }
429                                         if (mon.realowner != caller && autocvar_g_monsters_edit < 2) { print_to(caller, "This monster does not belong to you"); return; }
430
431                                         mon.monster_moveflags = stof(argument);
432                                         print_to(caller, strcat("Monster move target successfully changed to ", ftos(mon.monster_moveflags)));
433                                         return;
434                                 }
435                                 case "butcher":
436                                 {
437                                         if (caller) { print_to(caller, "This command is not available to players"); return; }
438                                         if (MUTATOR_CALLHOOK(AllowMobButcher)) { LOG_INFO(ret_string, "\n"); return; }
439
440                                         int tmp_remcount = 0;
441
442                                         FOREACH_ENTITY_FLAGS(flags, FL_MONSTER, LAMBDA(
443                                                 Monster_Remove(it);
444                                                 ++tmp_remcount;
445                                         ));
446
447                                         monsters_total = monsters_killed = totalspawned = 0;
448
449                                         print_to(caller, (tmp_remcount) ? sprintf("Killed %d monster%s", tmp_remcount, (tmp_remcount == 1) ? "" : "s") : "No monsters to kill");
450                                         return;
451                                 }
452                         }
453                 }
454
455                 default:
456                 case CMD_REQUEST_USAGE:
457                 {
458                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " editmob command [arguments]"));
459                         print_to(caller, "  Where 'command' can be butcher spawn skin movetarget kill name");
460                         print_to(caller, "  spawn, skin, movetarget and name require 'arguments'");
461                         print_to(caller, "  spawn also takes arguments list and random");
462                         print_to(caller, "  Monster will follow owner if third argument of spawn command is not defined");
463                         return;
464                 }
465         }
466 }
467
468 void CommonCommand_info(float request, entity caller, float argc)
469 {
470         switch (request)
471         {
472                 case CMD_REQUEST_COMMAND:
473                 {
474                         string command = builtin_cvar_string(strcat("sv_info_", argv(1)));
475
476                         if (command) wordwrap_sprint(command, 1000);
477                         else print_to(caller, "ERROR: unsupported info command");
478
479                         return;  // never fall through to usage
480                 }
481
482                 default:
483                 case CMD_REQUEST_USAGE:
484                 {
485                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " info request"));
486                         print_to(caller, "  Where 'request' is the suffixed string appended onto the request for cvar.");
487                         return;
488                 }
489         }
490 }
491
492 void CommonCommand_ladder(float request, entity caller)
493 {
494         switch (request)
495         {
496                 case CMD_REQUEST_COMMAND:
497                 {
498                         print_to(caller, ladder_reply);
499                         return;  // never fall through to usage
500                 }
501
502                 default:
503                 case CMD_REQUEST_USAGE:
504                 {
505                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " ladder"));
506                         print_to(caller, "  No arguments required.");
507                         return;
508                 }
509         }
510 }
511
512 void CommonCommand_lsmaps(float request, entity caller)
513 {
514         switch (request)
515         {
516                 case CMD_REQUEST_COMMAND:
517                 {
518                         print_to(caller, lsmaps_reply);
519                         return;  // never fall through to usage
520                 }
521
522                 default:
523                 case CMD_REQUEST_USAGE:
524                 {
525                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " lsmaps"));
526                         print_to(caller, "  No arguments required.");
527                         return;
528                 }
529         }
530 }
531
532 void CommonCommand_printmaplist(float request, entity caller)
533 {
534         switch (request)
535         {
536                 case CMD_REQUEST_COMMAND:
537                 {
538                         print_to(caller, maplist_reply);
539                         return;  // never fall through to usage
540                 }
541
542                 default:
543                 case CMD_REQUEST_USAGE:
544                 {
545                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " printmaplist"));
546                         print_to(caller, "  No arguments required.");
547                         return;
548                 }
549         }
550 }
551
552 void CommonCommand_rankings(float request, entity caller)
553 {
554         switch (request)
555         {
556                 case CMD_REQUEST_COMMAND:
557                 {
558                         print_to(caller, rankings_reply);
559                         return;  // never fall through to usage
560                 }
561
562                 default:
563                 case CMD_REQUEST_USAGE:
564                 {
565                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " rankings"));
566                         print_to(caller, "  No arguments required.");
567                         return;
568                 }
569         }
570 }
571
572 void CommonCommand_records(float request, entity caller)
573 {
574         switch (request)
575         {
576                 case CMD_REQUEST_COMMAND:
577                 {
578                         for (int i = 0; i < 10; ++i)
579                                 if (records_reply[i] != "") print_to(caller, records_reply[i]);
580
581                         return;  // never fall through to usage
582                 }
583
584                 default:
585                 case CMD_REQUEST_USAGE:
586                 {
587                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " records"));
588                         print_to(caller, "  No arguments required.");
589                         return;
590                 }
591         }
592 }
593
594 void CommonCommand_teamstatus(float request, entity caller)
595 {
596         switch (request)
597         {
598                 case CMD_REQUEST_COMMAND:
599                 {
600                         Score_NicePrint(caller);
601                         return;  // never fall through to usage
602                 }
603
604                 default:
605                 case CMD_REQUEST_USAGE:
606                 {
607                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " teamstatus"));
608                         print_to(caller, "  No arguments required.");
609                         return;
610                 }
611         }
612 }
613
614 void CommonCommand_time(float request, entity caller)
615 {
616         switch (request)
617         {
618                 case CMD_REQUEST_COMMAND:
619                 {
620                         print_to(caller, strcat("time = ", ftos(time)));
621                         print_to(caller, strcat("frame start = ", ftos(gettime(GETTIME_FRAMESTART))));
622                         print_to(caller, strcat("realtime = ", ftos(gettime(GETTIME_REALTIME))));
623                         print_to(caller, strcat("hires = ", ftos(gettime(GETTIME_HIRES))));
624                         print_to(caller, strcat("uptime = ", ftos(gettime(GETTIME_UPTIME))));
625                         print_to(caller, strcat("localtime = ", strftime(true, "%a %b %e %H:%M:%S %Z %Y")));
626                         print_to(caller, strcat("gmtime = ", strftime(false, "%a %b %e %H:%M:%S %Z %Y")));
627                         return;
628                 }
629
630                 default:
631                 case CMD_REQUEST_USAGE:
632                 {
633                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " time"));
634                         print_to(caller, "  No arguments required.");
635                         return;
636                 }
637         }
638 }
639
640 void CommonCommand_timein(float request, entity caller)
641 {
642         switch (request)
643         {
644                 case CMD_REQUEST_COMMAND:
645                 {
646                         if (!caller || autocvar_sv_timeout)
647                         {
648                                 if (!timeout_status) { print_to(caller, "^7Error: There is no active timeout called."); }
649                                 else if (caller && (caller != timeout_caller))
650                                 {
651                                         print_to(caller, "^7Error: You are not allowed to stop the active timeout.");
652                                 }
653
654                                 else  // everything should be okay, continue aborting timeout
655                                 {
656                                         switch (timeout_status)
657                                         {
658                                                 case TIMEOUT_LEADTIME:
659                                                 {
660                                                         timeout_status = TIMEOUT_INACTIVE;
661                                                         timeout_time = 0;
662                                                         timeout_handler.nextthink = time;  // timeout_handler has to take care of it immediately
663                                                         bprint(strcat("^7The timeout was aborted by ", GetCallerName(caller), " !\n"));
664                                                         return;
665                                                 }
666
667                                                 case TIMEOUT_ACTIVE:
668                                                 {
669                                                         timeout_time = autocvar_sv_timeout_resumetime;
670                                                         timeout_handler.nextthink = time;  // timeout_handler has to take care of it immediately
671                                                         bprint(strcat("^1Attention: ^7", GetCallerName(caller), " resumed the game! Prepare for battle!\n"));
672                                                         return;
673                                                 }
674
675                                                 default: LOG_TRACE("timeout status was inactive, but this code was executed anyway?");
676                                                         return;
677                                         }
678                                 }
679                         }
680                         else { print_to(caller, "^1Timeins are not allowed to be called, enable them with sv_timeout 1.\n"); }
681
682                         return;  // never fall through to usage
683                 }
684
685                 default:
686                 case CMD_REQUEST_USAGE:
687                 {
688                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " timein"));
689                         print_to(caller, "  No arguments required.");
690                         return;
691                 }
692         }
693 }
694
695 void CommonCommand_timeout(float request, entity caller)  // DEAR GOD THIS COMMAND IS TERRIBLE.
696 {
697         switch (request)
698         {
699                 case CMD_REQUEST_COMMAND:
700                 {
701                         if (!caller || autocvar_sv_timeout)
702                         {
703                                 float last_possible_timeout = ((autocvar_timelimit * 60) - autocvar_sv_timeout_leadtime - 1);
704
705                                 if (timeout_status) { print_to(caller, "^7Error: A timeout is already active."); }
706                                 else if (vote_called)
707                                 {
708                                         print_to(caller, "^7Error: You can not call a timeout while a vote is active.");
709                                 }
710                                 else if (warmup_stage && !g_warmup_allow_timeout)
711                                 {
712                                         print_to(caller, "^7Error: You can not call a timeout in warmup-stage.");
713                                 }
714                                 else if (time < game_starttime)
715                                 {
716                                         print_to(caller, "^7Error: You can not call a timeout while the map is being restarted.");
717                                 }
718                                 else if (caller && (caller.allowed_timeouts < 1))
719                                 {
720                                         print_to(caller, "^7Error: You already used all your timeout calls for this map.");
721                                 }
722                                 else if (caller && !IS_PLAYER(caller))
723                                 {
724                                         print_to(caller, "^7Error: You must be a player to call a timeout.");
725                                 }
726                                 else if ((autocvar_timelimit) && (last_possible_timeout < time - game_starttime))
727                                 {
728                                         print_to(caller, "^7Error: It is too late to call a timeout now!");
729                                 }
730
731                                 else  // everything should be okay, proceed with starting the timeout
732                                 {
733                                         if (caller)   caller.allowed_timeouts -= 1;
734                                         // write a bprint who started the timeout (and how many they have left)
735                                         bprint(GetCallerName(caller), " ^7called a timeout", (caller ? strcat(" (", ftos(caller.allowed_timeouts), " timeout(s) left)") : ""), "!\n");
736
737                                         timeout_status = TIMEOUT_LEADTIME;
738                                         timeout_caller = caller;
739                                         timeout_time = autocvar_sv_timeout_length;
740                                         timeout_leadtime = autocvar_sv_timeout_leadtime;
741
742                                         timeout_handler = spawn();
743                                         timeout_handler.think = timeout_handler_think;
744                                         timeout_handler.nextthink = time;  // always let the entity think asap
745
746                                         Send_Notification(NOTIF_ALL, world, MSG_ANNCE, ANNCE_TIMEOUT);
747                                 }
748                         }
749                         else { print_to(caller, "^1Timeouts are not allowed to be called, enable them with sv_timeout 1.\n"); }
750
751                         return;  // never fall through to usage
752                 }
753
754                 default:
755                 case CMD_REQUEST_USAGE:
756                 {
757                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " timeout"));
758                         print_to(caller, "  No arguments required.");
759                         return;
760                 }
761         }
762 }
763
764 void CommonCommand_who(float request, entity caller, float argc)
765 {
766         switch (request)
767         {
768                 case CMD_REQUEST_COMMAND:
769                 {
770                         float total_listed_players, is_bot;
771
772                         float privacy = (caller && autocvar_sv_status_privacy);
773                         string separator = strreplace("%", " ", strcat((argv(1) ? argv(1) : " "), "^7"));
774                         string tmp_netaddress, tmp_crypto_idfp;
775
776                         print_to(caller, strcat("List of client information", (privacy ? " (some data is hidden for privacy)" : ""), ":"));
777                         print_to(caller, sprintf(strreplace(" ", separator, " %-4s %-20s %-5s %-3s %-9s %-16s %s "),
778                                 "ent", "nickname", "ping", "pl", "time", "ip", "crypto_id"));
779
780                         total_listed_players = 0;
781                         FOREACH_CLIENT(true, LAMBDA(
782                                 is_bot = (IS_BOT_CLIENT(it));
783
784                                 if (is_bot)
785                                 {
786                                         tmp_netaddress = "null/botclient";
787                                         tmp_crypto_idfp = "null/botclient";
788                                 }
789                                 else if (privacy)
790                                 {
791                                         tmp_netaddress = "hidden";
792                                         tmp_crypto_idfp = "hidden";
793                                 }
794                                 else
795                                 {
796                                         tmp_netaddress = it.netaddress;
797                                         tmp_crypto_idfp = it.crypto_idfp;
798                                 }
799
800                                 print_to(caller, sprintf(strreplace(" ", separator, " #%-3d %-20.20s %-5d %-3d %-9s %-16s %s "),
801                                         etof(it),
802                                         it.netname,
803                                         it.ping,
804                                         it.ping_packetloss,
805                                         process_time(1, time - it.jointime),
806                                         tmp_netaddress,
807                                         tmp_crypto_idfp));
808
809                                 ++total_listed_players;
810                         ));
811
812                         print_to(caller, strcat("Finished listing ", ftos(total_listed_players), " client(s) out of ", ftos(maxclients), " slots."));
813
814                         return;  // never fall through to usage
815                 }
816
817                 default:
818                 case CMD_REQUEST_USAGE:
819                 {
820                         print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " who [separator]"));
821                         print_to(caller, "  Where 'separator' is the optional string to separate the values with, default is a space.");
822                         return;
823                 }
824         }
825 }
826
827 /* use this when creating a new command, making sure to place it in alphabetical order... also,
828 ** ADD ALL NEW COMMANDS TO commands.cfg WITH PROPER ALIASES IN THE SAME FASHION!
829 void CommonCommand_(float request, entity caller)
830 {
831     switch(request)
832     {
833         case CMD_REQUEST_COMMAND:
834         {
835
836             return; // never fall through to usage
837         }
838
839         default:
840         case CMD_REQUEST_USAGE:
841         {
842             print_to(caller, strcat("\nUsage:^3 ", GetCommandPrefix(caller), " "));
843             print_to(caller, "  No arguments required.");
844             return;
845         }
846     }
847 }
848 */