Added the capture-counter and changed the CTF scoreboard to display the caps.
[divverent/nexuiz.git] / data / qcsrc / server / clientcommands.qc
1 void ReadyCount();
2 void(entity e) DropFlag;
3 string MapVote_Suggest(string m);
4
5 .float floodcontrol_chat;
6 .float floodcontrol_team;
7 void Say(entity source, float teamsay, string msgin)
8 {
9         string msgstr, colorstr, cmsgstr, namestr;
10         float flood;
11         entity head;
12
13         if(!teamsay)
14                 if(substring(msgin, 0, 1) == " ")
15                         msgin = substring(msgin, 1, strlen(msgin) - 1); // work around DP say bug (say_team does not have this!)
16
17         msgin = formatmessage(msgin);
18
19         if(msgin == "")
20                 return;
21
22         if(source.classname != "player")
23                 colorstr = "^0"; // black for spectators
24         else if(teams_matter)
25                 colorstr = Team_ColorCode(source.team);
26         else
27                 teamsay = FALSE;
28
29         if(intermission_running)
30                 teamsay = FALSE;
31
32         /*
33          * using bprint solves this... me stupid
34         // how can we prevent the message from appearing in a listen server?
35         // for now, just give "say" back and only handle say_team
36         if(!teamsay)
37         {
38                 clientcommand(self, strcat("say ", msgin));
39                 return;
40         }
41         */
42
43         if(cvar("g_chat_teamcolors"))
44                 namestr = playername(source);
45         else
46                 namestr = source.netname;
47         if(teamsay)
48         {
49                 msgstr = strzone(strcat("\{1}\{13}", colorstr, "(^3", namestr, colorstr, ") ^7", msgin, "\n"));
50                 cmsgstr = strcat(colorstr, "(^3", namestr, colorstr, ")\n^7", wordwrap(msgin, 50));
51         }
52         else
53                 msgstr = strzone(strcat("\{1}", namestr, "^7: ", msgin, "\n"));
54
55         // FLOOD CONTROL
56         flood = 0;
57         {
58                 float flood_spl;
59                 float flood_burst;
60                 float flood_lmax;
61                 var .float flood_field;
62                 float lines;
63                 if(teamsay)
64                 {
65                         flood_spl = cvar("g_chat_flood_spl_team");
66                         flood_burst = cvar("g_chat_flood_burst_team");
67                         flood_lmax = cvar("g_chat_flood_lmax_team");
68                         flood_field = floodcontrol_team;
69                 }
70                 else
71                 {
72                         flood_spl = cvar("g_chat_flood_spl");
73                         flood_burst = cvar("g_chat_flood_burst");
74                         flood_lmax = cvar("g_chat_flood_lmax");
75                         flood_field = floodcontrol_chat;
76                 }
77                 flood_burst = max(0, flood_burst - 1);
78                 // to match explanation in default.cfg, a value of 3 must allow three-line bursts and not four!
79                 lines = ceil(strlennocol(msgstr) / 75);
80                 if(flood_lmax && lines > flood_lmax)
81                         flood = 2;
82                 else if(time >= self.flood_field)
83                         self.flood_field = max(time - flood_burst * flood_spl, self.flood_field) + lines * flood_spl;
84                 else
85                         flood = 1;
86         }
87
88         if(flood)
89         {
90                 if(cvar("g_chat_flood_notify_flooder"))
91                 {
92                         if(flood == 1)
93                                 sprint(self, strcat("^3FLOOD CONTROL: ^7wait ^1", ftos(self.flood_field - time), "^3 seconds\n"));
94                         else if(flood == 2)
95                                 sprint(self, "^3FLOOD CONTROL: ^7message too long\n");
96                 }
97                 else
98                         sprint(self, msgstr);
99                 ServerConsoleEcho(strcat("NOTE: ", playername(self), "^7 is flooding."), TRUE);
100         }
101         else if(teamsay)
102         {
103                 if(source.classname == "player")
104                 {
105                         FOR_EACH_REALPLAYER(head)
106                         {
107                                 if(head.team == source.team)
108                                 {
109                                         sprint(head, msgstr);
110                                         centerprint(head, cmsgstr);
111                                 }
112                         }
113                 }
114                 else
115                 {
116                         FOR_EACH_REALCLIENT(head) if(head.classname != "player")
117                         {
118                                 sprint(head, msgstr);
119                                 centerprint(head, cmsgstr);
120                         }
121                 }
122         }
123         else
124         {
125                 //when g_tourney is active and g_tourney_disable_spec_chat is set and game is in matchstage
126                 //don't print the text from specs/observers to the players but only the other spectators
127                 if(g_tourney && cvar("g_tourney_disable_spec_chat") && tourneyInMatchStage && source.classname != "player") {
128                         FOR_EACH_REALCLIENT(head) if(head.classname != "player") {
129                                 sprint(head, msgstr);
130                         }
131                 }
132                 else
133                         bprint(msgstr);
134                 //ServerConsoleEcho(substring(msgstr, 1, strlen(msgstr) - 2), TRUE);
135         }
136
137         strunzone(msgstr);
138 }
139
140 entity GetPlayer(string name)
141 {
142         float num;
143         entity e;
144         string ns;
145
146         if(substring(name, 0, 1) == "#") {
147                 num = stof(substring(name, 1, 999));
148                 if(num >= 1 && num <= maxclients) {
149                         for((e = world); num > 0; --num, (e = nextent(e)))
150                                 ;
151                         //if(clienttype(e) == CLIENTTYPE_REAL)
152                         if(e.classname == "player")
153                                 return e;
154                 }
155         } else {
156                 ns = strdecolorize(name);
157                 FOR_EACH_REALPLAYER(e) {
158                         if(!strcasecmp(strdecolorize(e.netname), ns)) {
159                                 return e;
160                         }
161                 }
162         }
163         return world;
164 }
165
166 //float ctf_clientcommand();
167 void SV_ParseClientCommand(string s) {
168         local string cmd;
169         local float i;
170
171         tokenize(s);
172
173         if(GameCommand_Vote(s, self)) {
174                 return;
175         } else if(argv(0) == "autoswitch") {
176                 // be backwards compatible with older clients (enabled)
177                 self.autoswitch = ("0" != argv(1));
178                 local string autoswitchmsg;
179                 if (self.autoswitch) {
180                         autoswitchmsg = "on";
181                 } else {
182                         autoswitchmsg = "off";
183                 }
184                 sprint(self, strcat("^1autoswitch turned ", autoswitchmsg, "\n"));
185         } else if(argv(0) == "clientversion") {
186                 if (argv(1) == "$gameversion") {
187                         //versionmsg = "^1client is too old to get versioninfo.\nUPDATE!!! (http://www.nexuiz.com)^8";
188                         // either that or someone wants to be funny
189                         self.version = 1;
190                 } else {
191                         self.version = stof(argv(1));
192                 }
193                 if(self.version != cvar("gameversion"))
194                 {
195                         self.classname = "observer";
196                         self.frags = -2;
197                         PutClientInServer();
198                 } else if(cvar("g_campaign") || cvar("g_balance_teams") || cvar("g_balance_teams_force")) {
199                         //JoinBestTeam(self, FALSE, TRUE);
200                 } else if(cvar("teamplay") && !cvar("sv_spectate")) {
201                         self.classname = "observer";
202                         stuffcmd(self,"menu_showteamselect\n");
203                 }
204         } else if(argv(0) == "reportcvar") { // old system
205                 GetCvars(1);
206         } else if(argv(0) == "sentcvar") { // new system
207                 GetCvars(1);
208         } else if(argv(0) == "spectate") {
209                 if(g_lms || g_arena)
210                         return; // don't allow spectating in lms, unless player runs out of lives
211                 if(self.classname == "player" && cvar("sv_spectate") == 1) {
212                         if(self.flagcarried)
213                                 DropFlag(self.flagcarried);
214                         kh_Key_DropAll(self, TRUE);
215                         WaypointSprite_PlayerDead();
216                         DistributeFragsAmongTeam(self, self.team, 1.0);
217                         self.captures = 0;
218                         ctf_UpdateCaptures();
219                         self.classname = "observer";
220                         if(blockSpectators)
221                                 sprint(self, strcat("^7You have to become a player within the next ", ftos(cvar("g_maxplayers_spectator_blocktime")), " seconds, otherwise you will be kicked, because spectators aren't allowed at this time!\n"));
222                         PutClientInServer();
223                 }
224         } else if(argv(0) == "join") {
225                 if(!g_arena)
226                 if (self.classname != "player" && !lockteams)
227                 {
228                         if(isJoinAllowed()) {
229                                 self.classname = "player";
230                                 self.frags = 0;
231                                 self.captures = 0;
232                                 ctf_UpdateCaptures();
233                                 bprint ("^4", self.netname, "^4 is playing now\n");
234                                 PutClientInServer();
235                         }
236                         else {
237                                 //player may not join because of g_maxplayers is set
238                                 centerprint_atprio(self, CENTERPRIO_MAPVOTE, PREVENT_JOIN_TEXT);
239                         }
240                 }
241         } else if( argv(0) == "selectteam" ) {
242                 if( !cvar("teamplay") ) {
243                         sprint( self, "selecteam can only be used in teamgames\n");
244                 } else if(cvar("g_campaign")) {
245                         //JoinBestTeam(self, 0);
246                 } else if(lockteams) {
247                         sprint( self, "^7The game has already begun, you must wait until the next map to be able to join a team.\n");
248                 } else if( argv(1) == "red" ) {
249                         DoTeamChange(COLOR_TEAM1);
250                 } else if( argv(1) == "blue" ) {
251                         DoTeamChange(COLOR_TEAM2);
252                 } else if( argv(1) == "yellow" ) {
253                         DoTeamChange(COLOR_TEAM3);
254                 } else if( argv(1) == "pink" ) {
255                         DoTeamChange(COLOR_TEAM4);
256                 } else if( argv(1) == "auto" ) {
257                         DoTeamChange(-1);
258                 } else {
259                         sprint( self, strcat( "selectteam none/red/blue/yellow/pink/auto - \"", argv(1), "\" not recognised\n" ) );
260                 }
261         } else if(argv(0) == "ready") {
262                 if(cvar("sv_ready_restart"))
263                 {
264                         if(timeoutStatus) {
265                                 return sprint(self, "^1You cannot reset the game while a timeout is active!\n");
266                         }
267                         
268                         if(!restart_countdown || cvar("sv_ready_restart_repeatable"))
269                         {
270                                 self.ready = TRUE;
271                                 bprint(self.netname, "^2 is ready\n");
272                                 ReadyCount();
273                         } else {
274                                 sprint(self, "^1game has already been restarted\n");
275                         }
276                 }
277         } else if(argv(0) == "maplist") {
278                 local float n;
279                 local string col;
280                 n = tokenize(cvar_string("g_maplist"));
281                 sprint(self, "^7Maps in list: ");
282                 for(i = 0; i < n; ++i)
283                 {
284                         if(mod(i, 2))
285                                 col = "^2";
286                         else
287                                 col = "^3";
288                         sprint(self, strcat(col, argv(i), " "));
289                 }
290                 sprint(self, "\n");
291 #ifdef MAPINFO
292         } else if(argv(0) == "lsmaps") {
293                 sprint(self, "^7Maps available: ");
294                 for(i = 0; i < MapInfo_count; ++i)
295                 {
296                         if(mod(i, 2))
297                                 col = "^2";
298                         else
299                                 col = "^3";
300                         sprint(self, strcat(col, MapInfo_BSPName_ByID(i), " "));
301                 }
302                 sprint(self, "\n");
303 #endif
304         } else if(argv(0) == "teamstatus") {
305                 PrintScoreboard(self);
306         } else if(argv(0) == "voice") {
307                 VoiceMessage(argv(1));
308         } else if(argv(0) == "say") {
309                 Say(self, FALSE, substring(s, 4, strlen(s) - 4));
310                 //clientcommand(self, formatmessage(s));
311         } else if(argv(0) == "say_team") {
312                 Say(self, TRUE, substring(s, 9, strlen(s) - 9));
313                 //clientcommand(self, formatmessage(s));
314         } else if(argv(0) == "info") {
315                 cmd = cvar_string(strcat("sv_info_", argv(1)));
316                 if(cmd == "")
317                         sprint(self, "ERROR: unsupported info command\n");
318                 else
319                         wordwrap_sprint(cmd, 1111);
320         } else if(argv(0) == "suggestmap") {
321                 sprint(self, strcat(MapVote_Suggest(argv(1)), "\n"));
322         } else if(argv(0) == "calltimeout") {
323                 if(cvar("sv_timeout")) {
324                         if(self.classname == "player") {
325                                 if(votecalled)
326                                         sprint(self, "^7Error: you can not call a timeout while a vote is active!\n");
327                                 else
328                                         evaluateTimeoutCall();
329                         }
330                         else
331                                 sprint(self, "^7Error: only players can call a timeout!\n");
332                 }
333         } else if(argv(0) == "resumegame") {
334                 if(cvar("sv_timeout")) {
335                         evaluateResumeGame();
336                 }
337         } else {
338                 //if(ctf_clientcommand())
339                 //      return;
340                 cmd = argv(0);
341                 /* checks not needed any more since DP has separated clientcommands and regular commands
342                 if(cmd != "status")
343                 if(cmd != "name")
344                 //if(cmd != "say") // handled above
345                 //if(cmd != "say_team") // handled above
346                 if(cmd != "tell")
347                 if(cmd != "color")
348                 if(cmd != "kill")
349                 if(cmd != "pause")
350                 if(cmd != "kick")
351                 if(cmd != "ping")
352                 if(cmd != "pings")
353                 if(cmd != "ban")
354                 if(cmd != "pmodel")
355                 if(cmd != "rate")
356                 if(cmd != "playermodel")
357                 if(cmd != "playerskin")
358                 if(cmd != "god") if(cmd != "notarget") if(cmd != "fly") if(cmd != "give") if(cmd != "noclip")
359                 {
360                         ServerConsoleEcho(strcat("WARNING: Invalid clientcommand by ", self.netname, ": ", s), TRUE);
361                         return;
362                 }
363                 */
364                 clientcommand(self,s);
365         }
366 }
367
368 /**
369  * Counts how many players are ready. If not enough players are ready, the function
370  * does nothing. If all players are ready, the timelimit will be extended and the
371  * restart_countdown variable is set to allow other functions like PlayerPostThink
372  * to detect that the countdown is now active. If the cvar sv_ready_restart_after_countdown
373  * is not set the map will be resetted.
374  * 
375  * Function is called after the server receives a 'ready' sign from a player.
376  */
377 void ReadyCount()
378 {
379         local entity e;
380         local float r, p;
381
382         FOR_EACH_REALPLAYER(e)
383         {
384                 p += 1;
385                 if(e.ready)
386                         r += 1;
387         }
388
389         if(cvar("sv_ready_restart_nag")) {
390                 if(!readyNagActive) {
391                         readyNagger = spawn();
392                         readyNagger.think = readyNagger_Think;
393                         readyNagger.cnt = cvar("sv_ready_restart_nag_duration");
394                         readyNagger.nextthink = time;
395                         readyNagActive = 1;
396                 }
397         }
398
399         if(!p || r < p)
400                 return;
401
402         bprint("^1Server is restarting...\n");
403
404         // no arena, assault support yet...
405         if(g_arena | g_assault | gameover | intermission_running)
406                 localcmd("restart\n");
407
408         if(readyNagActive) { //if every player is ready, remove the ready-nagger again
409                 readyNagActive = 0;
410                 remove(readyNagger);
411         }
412
413         if(g_tourney) {
414                 tourneyInMatchStage = 1; //once the game is restarted the game is in match stage
415                 //reset weapons and ammo, health and armor to default:
416                 start_items = IT_LASER | IT_SHOTGUN;
417                 start_switchweapon = WEP_SHOTGUN;
418                 start_ammo_shells = cvar("g_start_ammo_shells");
419                 start_ammo_nails = cvar("g_start_ammo_nails");
420                 start_ammo_rockets = cvar("g_start_ammo_rockets");
421                 start_ammo_cells = cvar("g_start_ammo_cells");
422                 start_health = cvar("g_balance_health_start");
423                 start_armorvalue = cvar("g_balance_armor_start");
424         }
425
426         restart_countdown = time + RESTART_COUNTDOWN;
427         restart_mapalreadyrestarted = 0; //reset this var, needed when cvar sv_ready_restart_repeatable is in use
428         //reset the .ready status of all players (also spectators)
429         FOR_EACH_CLIENT(e)
430         {
431                 e.ready = 0;
432         }
433         if(0<cvar("timelimit") || (g_tourney && cvar("g_tourney_warmup_unlimited_time")) )
434         {
435                 // remember original timelimit on first restart
436                 if(!timelimit_orig)
437                         timelimit_orig = cvar("timelimit");
438                 //only set the new timelimit if, when loading the map, a timelimit was really set
439                 if(timelimit_orig)
440                         cvar_set("timelimit", ftos(timelimit_orig + ceil(restart_countdown)/60));
441         }
442         if(cvar("teamplay_lockonrestart") && teams_matter) {
443                 lockteams = 1;
444                 bprint("^1The teams are now locked.\n");
445         }
446         
447         //initiate the restart-countdown-announcer entity
448         restartAnnouncer = spawn();
449         restartAnnouncer.think = restartAnnouncer_Think;
450         restartAnnouncer.nextthink = time;
451         restartAnnouncer.cnt = RESTART_COUNTDOWN;
452         
453         //after a restart every players number of allowed timeouts gets reset, too
454         if(cvar("sv_timeout"))
455         {
456                 FOR_EACH_REALPLAYER(e)
457                 {
458                         e.allowedTimeouts = cvar("sv_timeout_number");
459                 }
460         }
461
462         //play the prepareforbattle sound to everyone
463         sound(world, CHAN_AUTO, "announcer/robotic/prepareforbattle.wav", 1, ATTN_NONE);
464
465         //reset map immediately if this cvar is not set
466         if (!cvar("sv_ready_restart_after_countdown"))
467                 reset_map();
468         
469         if(cvar("sv_eventlog"))
470                 GameLogEcho(":restart", FALSE);
471 }
472
473 /**
474  * Centerprints the information to all players who didn't ready up yet to do so.
475  */
476 void readyNagger_Think() {
477         local entity plr;
478         if(self.cnt <= 0) { //have a break showing the ready nag
479                 //make sure that the old ready-nag-centerprint isn't shown too long:
480                 FOR_EACH_REALCLIENT(plr) {
481                         if(plr.classname == "player") {
482                                 if (!plr.ready)
483                                         centerprint_atprio(plr, CENTERPRIO_SPAM, "");
484                         }
485                 }
486                 self.cnt = cvar("sv_ready_restart_nag_duration");
487                 self.nextthink = time + cvar("sv_ready_restart_nag_interval");
488         }
489         else {
490                 //show the ready nagging to all players who aren't ready yet
491                 FOR_EACH_REALCLIENT(plr) {
492                         if(plr.classname == "player") {
493                                 if (!plr.ready) {
494                                         centerprint_atprio(plr, CENTERPRIO_SPAM, "^2Please ready up (F4 by default)!");
495                                         //play reminder sound once the centerprint appears for the first time after the pause:
496                                         if (self.cnt == cvar("sv_ready_restart_nag_duration"))
497                                                 play2(plr, "misc/talk2.wav");
498                                 }
499                         }
500                 }
501
502                 self.nextthink = time + 1;
503                 self.cnt -= 1;
504         }
505 }
506
507 /**
508  * Shows the restart countdown for all players.
509  * Plays the countdown sounds for the seconds 3, 2 1, begin for everyone.
510  * Restarts the map after the countdown is over (and cvar sv_ready_restart_after_countdown
511  * is set to 1).
512  */
513 void restartAnnouncer_Think() {
514         local entity plr;
515         local string s;
516         if(self.cnt <= 0) { //show the "Begin" message and
517                 if (cvar("sv_ready_restart_after_countdown")) {
518                         restart_mapalreadyrestarted = 1;
519                         reset_map();
520                 }
521
522                 FOR_EACH_REALCLIENT(plr) {
523                         if(plr.classname == "player") {
524                                 s = strcat(NEWLINES, "^1Begin!");
525                                 centerprint(plr, s);
526                         }
527                 }
528                 sound(world, CHAN_AUTO, "announcer/robotic/begin.wav", 1, ATTN_NONE);
529
530                 remove(self);
531                 return;
532         }
533         else {
534                 FOR_EACH_REALCLIENT(plr) {
535                         if(plr.classname == "player") {
536                                 s = strcat(NEWLINES, "^1Game starts in ", ftos(self.cnt), " seconds");
537                                 centerprint(plr, s);
538                         }
539                 }
540
541                 if(self.cnt <= 3) {
542                         sound(world, CHAN_AUTO, strcat("announcer/robotic/", ftos(self.cnt), ".ogg"), 1, ATTN_NONE);
543                 }
544                 self.nextthink = time + 1;
545                 self.cnt -= 1;
546         }
547 }
548
549 /**
550  * Checks whether the player who calls the timeout is allowed to do so.
551  * If so, it initializes the timeout countdown. It also checks whether another
552  * timeout was already running at this time and reacts correspondingly.
553  *
554  * affected globals/fields: .allowedTimeouts, remainingTimeoutTime, remainingLeadTime,
555  *                          timeoutInitiator, timeoutStatus, timeoutHandler
556  *
557  * This function is called when a player issues the calltimeout command.
558  */
559 void evaluateTimeoutCall() {
560         if (g_tourney && !tourneyInMatchStage && !cvar("g_tourney_warmup_allow_timeout"))
561                 return sprint(self, "^7Error: You can not call a timeout in warmup-stage!\n");
562         if (time < restart_countdown )
563                 return sprint(self, "^7Error: You can not call a timeout while the map is being restarted!\n");
564         if (timeoutStatus != 2) {
565                 //if the map uses a timelimit make sure that timeout cannot be called right before the map ends
566                 if (cvar("timelimit")) {
567                         //a timelimit was used
568                         local float myTl;
569                         if (cvar("timelimit"))
570                                 myTl = cvar("timelimit");
571                         else
572                                 myTl = timelimit_orig;
573
574                         local float lastPossibleTimeout;
575                         lastPossibleTimeout = (myTl*60) - cvar("sv_timeout_leadtime") - 1;
576
577                         if (lastPossibleTimeout < time)
578                                 return sprint(self, "^7Error: It is too late to call a timeout now!\n");
579                 }
580         }
581         //player may not call a timeout if he has no calls left
582         if (self.allowedTimeouts < 1)
583                 return sprint(self, "^7Error: You already used all your timeout calls for this map!\n");
584         //now all required checks are passed
585         self.allowedTimeouts -= 1;
586         bprint(self.netname, " ^7called a timeout (", ftos(self.allowedTimeouts), " timeouts left)!\n"); //write a bprint who started the timeout (and how many he has left)
587         remainingTimeoutTime = cvar("sv_timeout_length");
588         remainingLeadTime = cvar("sv_timeout_leadtime");
589         timeoutInitiator = self;
590         if (timeoutStatus == 0) { //if another timeout was already active, don't change its status (which was 1 or 2) to 1, only change it to 1 if no timeout was active yet
591                 timeoutStatus = 1;
592                 //create the timeout indicator which centerprints the information to all players and takes care of pausing/unpausing
593                 timeoutHandler = spawn();
594                 timeoutHandler.think = timeoutHandler_Think;
595         }
596         timeoutHandler.nextthink = time; //always let the entity think asap
597
598         //inform all connected clients about the timeout call
599         sound(world, CHAN_AUTO, "announcer/robotic/timeoutcalled.wav", 1, ATTN_NONE);
600 }
601
602 /**
603  * Checks whether a player is allowed to resume the game. If he is allowed to do it,
604  * and the lead time for the timeout is still active, this countdown just will be aborted (the
605  * game will never be paused). Otherwise the remainingTimeoutTime will be set to the corresponding
606  * value of the cvar sv_timeout_resumetime.
607  *
608  * This function is called when a player issues the resumegame command.
609  */
610 void evaluateResumeGame() {
611         if (!timeoutStatus)
612                 return sprint(self, "^7Error: There is no active timeout which could be aborted!\n");
613         if (self != timeoutInitiator)
614                 return sprint(self, "^7Error: You may not abort the active timeout. Only the player who called it can do that!\n");
615         if (timeoutStatus == 1) {
616                 remainingTimeoutTime = timeoutStatus = 0;
617                 timeoutHandler.nextthink = time; //timeoutHandler has to take care of it immediately
618                 bprint(strcat("^7The timeout was aborted by ", self.netname, " !\n"));
619         }
620         else if (timeoutStatus == 2) {
621                 //only shorten the remainingTimeoutTime if it makes sense
622                 if( remainingTimeoutTime > (cvar("sv_timeout_resumetime") + 1) ) {
623                         bprint(strcat("^1Attention: ^7", self.netname, " resumed the game! Prepare for battle!\n"));
624                         remainingTimeoutTime = cvar("sv_timeout_resumetime");
625                         timeoutHandler.nextthink = time; //timeoutHandler has to take care of it immediately
626                 }
627                 else
628                         sprint(self, "^7Error: Your resumegame call was discarded!\n");
629
630         }
631 }