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