Merge branch 'master' into Mario/vehicles
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / command / cmd.qc
1 #include "../../common/command/command.qh"
2 #include "cmd.qh"
3 #include "../_all.qh"
4
5 #include "common.qh"
6 #include "vote.qh"
7
8 #include "../campaign.qh"
9 #include "../cheats.qh"
10 #include "../cl_player.qh"
11 #include "../ipban.qh"
12 #include "../mapvoting.qh"
13 #include "../scores.qh"
14 #include "../teamplay.qh"
15
16 #include "../mutators/mutators_include.qh"
17
18 #ifdef SVQC
19         #include "../../common/vehicles/sv_vehicles.qh"
20 #endif
21
22 #include "../../common/constants.qh"
23 #include "../../common/deathtypes.qh"
24 #include "../../common/mapinfo.qh"
25 #include "../../common/notifications.qh"
26 #include "../../common/teams.qh"
27 #include "../../common/util.qh"
28
29 #include "../../common/monsters/all.qc"
30 #include "../../common/monsters/spawn.qh"
31 #include "../../common/monsters/sv_monsters.qh"
32
33 #include "../../warpzonelib/common.qh"
34
35 void ClientKill_TeamChange (float targetteam); // 0 = don't change, -1 = auto, -2 = spec
36
37 // =========================================================
38 //  Server side networked commands code, reworked by Samual
39 //  Last updated: December 28th, 2011
40 // =========================================================
41
42 float SV_ParseClientCommand_floodcheck()
43 {
44         if (!timeout_status) // not while paused
45         {
46                 if(time <= (self.cmd_floodtime + autocvar_sv_clientcommand_antispam_time))
47                 {
48                         self.cmd_floodcount += 1;
49                         if(self.cmd_floodcount > autocvar_sv_clientcommand_antispam_count) { return false; } // too much spam, halt
50                 }
51                 else
52                 {
53                         self.cmd_floodtime = time;
54                         self.cmd_floodcount = 1;
55                 }
56         }
57         return true; // continue, as we're not flooding yet
58 }
59
60
61 // =======================
62 //  Command Sub-Functions
63 // =======================
64
65 void ClientCommand_autoswitch(float request, float argc)
66 {
67         switch(request)
68         {
69                 case CMD_REQUEST_COMMAND:
70                 {
71                         if(argv(1) != "")
72                         {
73                                 self.autoswitch = InterpretBoolean(argv(1));
74                                 sprint(self, strcat("^1autoswitch is currently turned ", (self.autoswitch ? "on" : "off"), ".\n"));
75                                 return;
76                         }
77                 }
78
79                 default:
80                         sprint(self, "Incorrect parameters for ^2autoswitch^7\n");
81                 case CMD_REQUEST_USAGE:
82                 {
83                         sprint(self, "\nUsage:^3 cmd autoswitch selection\n");
84                         sprint(self, "  Where 'selection' controls if autoswitch is on or off.\n");
85                         return;
86                 }
87         }
88 }
89
90 void ClientCommand_checkfail(float request, string command) // internal command, used only by code
91 {
92         switch(request)
93         {
94                 case CMD_REQUEST_COMMAND:
95                 {
96                         printf("CHECKFAIL: %s (%s) epically failed check %s\n", self.netname, self.netaddress, substring(command, argv_start_index(1), argv_end_index(-1) - argv_start_index(1)));
97                         self.checkfail = 1;
98                         return; // never fall through to usage
99                 }
100
101                 default:
102                         sprint(self, "Incorrect parameters for ^2checkfail^7\n");
103                 case CMD_REQUEST_USAGE:
104                 {
105                         sprint(self, "\nUsage:^3 cmd checkfail <message>\n");
106                         sprint(self, "  Where 'message' is the message reported by client about the fail.\n");
107                         return;
108                 }
109         }
110 }
111
112 void ClientCommand_clientversion(float request, float argc) // internal command, used only by code
113 {
114         switch(request)
115         {
116                 case CMD_REQUEST_COMMAND:
117                 {
118                         if(argv(1) != "")
119                         {
120                                 if(IS_CLIENT(self))
121                                 {
122                                         self.version = ((argv(1) == "$gameversion") ? 1 : stof(argv(1)));
123
124                                         if(self.version < autocvar_gameversion_min || self.version > autocvar_gameversion_max)
125                                         {
126                                                 self.version_mismatch = 1;
127                                                 ClientKill_TeamChange(-2); // observe
128                                         }
129                                         else if(autocvar_g_campaign || autocvar_g_balance_teams)
130                                         {
131                                                 //JoinBestTeam(self, false, true);
132                                         }
133                                         else if(teamplay && !autocvar_sv_spectate && !(self.team_forced > 0))
134                                         {
135                                                 self.classname = "observer"; // really?
136                                                 stuffcmd(self, "menu_showteamselect\n");
137                                         }
138                                 }
139
140                                 return;
141                         }
142                 }
143
144                 default:
145                         sprint(self, "Incorrect parameters for ^2clientversion^7\n");
146                 case CMD_REQUEST_USAGE:
147                 {
148                         sprint(self, "\nUsage:^3 cmd clientversion version\n");
149                         sprint(self, "  Where 'version' is the game version reported by self.\n");
150                         return;
151                 }
152         }
153 }
154
155 void ClientCommand_mv_getpicture(float request, float argc) // internal command, used only by code
156 {
157         switch(request)
158         {
159                 case CMD_REQUEST_COMMAND:
160                 {
161                         if(argv(1) != "")
162                         {
163                                 if(intermission_running)
164                                         MapVote_SendPicture(stof(argv(1)));
165
166                                 return;
167                         }
168                 }
169
170                 default:
171                         sprint(self, "Incorrect parameters for ^2mv_getpicture^7\n");
172                 case CMD_REQUEST_USAGE:
173                 {
174                         sprint(self, "\nUsage:^3 cmd mv_getpicture mapid\n");
175                         sprint(self, "  Where 'mapid' is the id number of the map to request an image of on the map vote selection menu.\n");
176                         return;
177                 }
178         }
179 }
180
181 void ClientCommand_join(float request)
182 {
183         switch(request)
184         {
185                 case CMD_REQUEST_COMMAND:
186                 {
187                         if(IS_CLIENT(self))
188                         {
189                                 if(!IS_PLAYER(self) && !lockteams && !gameover)
190                                 {
191                                         if(self.caplayer)
192                                                 return;
193                                         if(nJoinAllowed(self))
194                                         {
195                                                 if(autocvar_g_campaign) { campaign_bots_may_start = 1; }
196
197                                                 self.classname = "player";
198                                                 PlayerScore_Clear(self);
199                                                 Kill_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER_CPID, CPID_PREVENT_JOIN);
200                                                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_JOIN_PLAY, self.netname);
201                                                 PutClientInServer();
202                                         }
203                                         else
204                                         {
205                                                 //player may not join because of g_maxplayers is set
206                                                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_JOIN_PREVENT);
207                                         }
208                                 }
209                         }
210                         return; // never fall through to usage
211                 }
212
213                 default:
214                 case CMD_REQUEST_USAGE:
215                 {
216                         sprint(self, "\nUsage:^3 cmd join\n");
217                         sprint(self, "  No arguments required.\n");
218                         return;
219                 }
220         }
221 }
222
223 void ClientCommand_mobedit(float request, float argc)
224 {
225         switch(request)
226         {
227                 case CMD_REQUEST_COMMAND:
228                 {
229                         if(argv(1) && argv(2))
230                         {
231                                 makevectors(self.v_angle);
232                                 WarpZone_TraceLine(self.origin + self.view_ofs, self.origin + self.view_ofs + v_forward * 100, MOVE_NORMAL, self);
233
234                                 if(!autocvar_g_monsters_edit) { sprint(self, "Monster property editing is not enabled.\n"); return; }
235                                 if(IS_MONSTER(trace_ent))
236                                 {
237                                         if(trace_ent.realowner != self) { sprint(self, "That monster does not belong to you.\n"); return; }
238                                         switch(argv(1))
239                                         {
240                                                 case "skin":
241                                                 {
242                                                         if(trace_ent.monsterid != MON_MAGE.monsterid)
243                                                                 trace_ent.skin = stof(argv(2));
244                                                         return;
245                                                 }
246                                                 case "movetarget":
247                                                 {
248                                                         trace_ent.monster_moveflags = stof(argv(2));
249                                                         return;
250                                                 }
251                                         }
252                                 }
253                         }
254                 }
255                 default:
256                         sprint(self, "Incorrect parameters for ^2mobedit^7\n");
257                 case CMD_REQUEST_USAGE:
258                 {
259                         sprint(self, "\nUsage:^3 cmd mobedit [argument]\n");
260                         sprint(self, "  Where 'argument' can be skin or movetarget.\n");
261                         sprint(self, "  Aim at your monster to edit its properties.\n");
262                         return;
263                 }
264         }
265 }
266
267 void ClientCommand_mobkill(float request)
268 {
269         switch(request)
270         {
271                 case CMD_REQUEST_COMMAND:
272                 {
273                         makevectors(self.v_angle);
274                         WarpZone_TraceLine(self.origin + self.view_ofs, self.origin + self.view_ofs + v_forward * 100, MOVE_NORMAL, self);
275
276                         if(IS_MONSTER(trace_ent))
277                         {
278                                 if(trace_ent.realowner != self)
279                                 {
280                                         sprint(self, "That monster does not belong to you.\n");
281                                         return;
282                                 }
283                                 sprint(self, strcat("Your pet '", trace_ent.monster_name, "' has been brutally mutilated.\n"));
284                                 Damage (trace_ent, world, world, trace_ent.health + trace_ent.max_health + 200, DEATH_KILL, trace_ent.origin, '0 0 0');
285                                 return;
286                         }
287                 }
288
289                 default:
290                         sprint(self, "Incorrect parameters for ^2mobkill^7\n");
291                 case CMD_REQUEST_USAGE:
292                 {
293                         sprint(self, "\nUsage:^3 cmd mobkill\n");
294                         sprint(self, "  Aim at your monster to kill it.\n");
295                         return;
296                 }
297         }
298 }
299
300 void ClientCommand_mobspawn(float request, float argc)
301 {
302         switch(request)
303         {
304                 case CMD_REQUEST_COMMAND:
305                 {
306                         entity e;
307                         string tospawn;
308                         float moveflag, monstercount = 0;
309
310                         moveflag = (argv(2) ? stof(argv(2)) : 1); // follow owner if not defined
311                         tospawn = strtolower(argv(1));
312
313                         if(tospawn == "list")
314                         {
315                                 sprint(self, monsterlist_reply);
316                                 return;
317                         }
318
319                         FOR_EACH_MONSTER(e)
320                         {
321                                 if(e.realowner == self)
322                                         ++monstercount;
323                         }
324
325                         if(autocvar_g_monsters_max <= 0 || autocvar_g_monsters_max_perplayer <= 0) { sprint(self, "Monster spawning is disabled.\n"); return; }
326                         else if(!IS_PLAYER(self)) { sprint(self, "You can't spawn monsters while spectating.\n"); return; }
327                         else if(MUTATOR_CALLHOOK(AllowMobSpawning)) { sprint(self, "Monster spawning is currently disabled by a mutator.\n"); return; }
328                         else if(!autocvar_g_monsters) { Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_MONSTERS_DISABLED); return; }
329                         else if(self.vehicle) { sprint(self, "You can't spawn monsters while driving a vehicle.\n"); return; }
330                         else if(self.frozen) { sprint(self, "You can't spawn monsters while frozen.\n"); return; }
331                         else if(autocvar_g_campaign) { sprint(self, "You can't spawn monsters in campaign mode.\n"); return; }
332                         else if(self.deadflag != DEAD_NO) { sprint(self, "You can't spawn monsters while dead.\n"); return; }
333                         else if(monstercount >= autocvar_g_monsters_max_perplayer) { sprint(self, "You have spawned too many monsters, kill some before trying to spawn any more.\n"); return; }
334                         else if(totalspawned >= autocvar_g_monsters_max) { sprint(self, "The global maximum monster count has been reached, kill some before trying to spawn any more.\n"); return; }
335                         else if(tospawn != "")
336                         {
337                                 float found = 0, i;
338                                 entity mon;
339
340                                 for(i = MON_FIRST; i <= MON_LAST; ++i)
341                                 {
342                                         mon = get_monsterinfo(i);
343                                         if(mon.netname == tospawn)
344                                         {
345                                                 found = true;
346                                                 break;
347                                         }
348                                 }
349
350                                 if(found || tospawn == "random")
351                                 {
352                                         totalspawned += 1;
353
354                                         makevectors(self.v_angle);
355                                         WarpZone_TraceBox (CENTER_OR_VIEWOFS(self), PL_MIN, PL_MAX, CENTER_OR_VIEWOFS(self) + v_forward * 150, true, self);
356                                         //WarpZone_TraceLine(self.origin + self.view_ofs, self.origin + self.view_ofs + v_forward * 150, MOVE_NORMAL, self);
357
358                                         e = spawnmonster(tospawn, 0, self, self, trace_endpos, false, false, moveflag);
359
360                                         sprint(self, strcat("Spawned ", e.monster_name, "\n"));
361
362                                         return;
363                                 }
364                         }
365                 }
366
367                 default:
368                         sprint(self, "Incorrect parameters for ^2mobspawn^7\n");
369                 case CMD_REQUEST_USAGE:
370                 {
371                         sprint(self, "\nUsage:^3 cmd mobspawn <random> <monster> [movetype]\n");
372                         sprint(self, "  See 'cmd mobspawn list' for available monsters.\n");
373                         sprint(self, "  Argument 'random' spawns a random monster.\n");
374                         sprint(self, "  Monster will follow the owner if second argument is not defined.\n");
375                         return;
376                 }
377         }
378 }
379
380 void ClientCommand_physics(float request, float argc)
381 {
382         switch(request)
383         {
384                 case CMD_REQUEST_COMMAND:
385                 {
386                         string command = strtolower(argv(1));
387                         
388                         if(!autocvar_g_physics_clientselect)
389                         {
390                                 sprint(self, "Client physics selection is currently disabled.\n");
391                                 return;
392                         }
393
394                         if(command == "list" || command == "help")
395                         {
396                                 sprint(self, strcat("Available physics sets: \n\n", autocvar_g_physics_clientselect_options, " default\n"));
397                                 return;
398                         }
399                         
400                         if(Physics_Valid(command) || command == "default")
401                         {
402                                 stuffcmd(self, strcat("\nseta cl_physics ", command, "\nsendcvar cl_physics\n"));
403                                 sprint(self, strcat("^2Physics set successfully changed to ^3", command, "\n"));
404                                 return;
405                         }
406                 }
407         
408                 default:
409                         sprint(self, strcat("Current physics set: ^3", self.cvar_cl_physics, "\n"));
410                 case CMD_REQUEST_USAGE:
411                 {
412                         sprint(self, "\nUsage:^3 cmd physics <physics>\n");
413                         sprint(self, "  See 'cmd physics list' for available physics sets.\n");
414                         sprint(self, "  Argument 'default' resets to standard physics.\n");
415                         return;
416                 }
417         }
418 }
419
420 void ClientCommand_ready(float request) // todo: anti-spam for toggling readyness
421 {
422         switch(request)
423         {
424                 case CMD_REQUEST_COMMAND:
425                 {
426                         if(IS_CLIENT(self))
427                         {
428                                 if(warmup_stage || autocvar_sv_ready_restart || g_race_qualifying == 2)
429                                 {
430                                         if(!readyrestart_happened || autocvar_sv_ready_restart_repeatable)
431                                         {
432                                                 if(time < game_starttime) // game is already restarting
433                                                         return;
434                                                 if (self.ready) // toggle
435                                                 {
436                                                         self.ready = false;
437                                                         bprint(self.netname, "^2 is ^1NOT^2 ready\n");
438                                                 }
439                                                 else
440                                                 {
441                                                         self.ready = true;
442                                                         bprint(self.netname, "^2 is ready\n");
443                                                 }
444
445                                                 // cannot reset the game while a timeout is active!
446                                                 if (!timeout_status)
447                                                         ReadyCount();
448                                         } else {
449                                                 sprint(self, "^1Game has already been restarted\n");
450                                         }
451                                 }
452                         }
453                         return; // never fall through to usage
454                 }
455
456                 default:
457                 case CMD_REQUEST_USAGE:
458                 {
459                         sprint(self, "\nUsage:^3 cmd ready\n");
460                         sprint(self, "  No arguments required.\n");
461                         return;
462                 }
463         }
464 }
465
466 void ClientCommand_say(float request, float argc, string command)
467 {
468         switch(request)
469         {
470                 case CMD_REQUEST_COMMAND:
471                 {
472                         if(argc >= 2) { Say(self, false, world, substring(command, argv_start_index(1), argv_end_index(-1) - argv_start_index(1)), 1); }
473                         return; // never fall through to usage
474                 }
475
476                 default:
477                 case CMD_REQUEST_USAGE:
478                 {
479                         sprint(self, "\nUsage:^3 cmd say <message>\n");
480                         sprint(self, "  Where 'message' is the string of text to say.\n");
481                         return;
482                 }
483         }
484 }
485
486 void ClientCommand_say_team(float request, float argc, string command)
487 {
488         switch(request)
489         {
490                 case CMD_REQUEST_COMMAND:
491                 {
492                         if(argc >= 2) { Say(self, true, world, substring(command, argv_start_index(1), argv_end_index(-1) - argv_start_index(1)), 1); }
493                         return; // never fall through to usage
494                 }
495
496                 default:
497                 case CMD_REQUEST_USAGE:
498                 {
499                         sprint(self, "\nUsage:^3 cmd say_team <message>\n");
500                         sprint(self, "  Where 'message' is the string of text to say.\n");
501                         return;
502                 }
503         }
504 }
505
506 void ClientCommand_selectteam(float request, float argc)
507 {
508         switch(request)
509         {
510                 case CMD_REQUEST_COMMAND:
511                 {
512                         if(argv(1) != "")
513                         {
514                                 if(IS_CLIENT(self))
515                                 {
516                                         if(teamplay)
517                                                 if(self.team_forced <= 0)
518                                                         if (!lockteams)
519                                                         {
520                                                                 float selection;
521
522                                                                 switch(argv(1))
523                                                                 {
524                                                                         case "red": selection = NUM_TEAM_1; break;
525                                                                         case "blue": selection = NUM_TEAM_2; break;
526                                                                         case "yellow": selection = NUM_TEAM_3; break;
527                                                                         case "pink": selection = NUM_TEAM_4; break;
528                                                                         case "auto": selection = (-1); break;
529
530                                                                         default: selection = 0; break;
531                                                                 }
532
533                                                                 if(selection)
534                                                                 {
535                                                                         if(self.team == selection && self.deadflag == DEAD_NO)
536                                                                                 sprint(self, "^7You already are on that team.\n");
537                                                                         else if(self.wasplayer && autocvar_g_changeteam_banned)
538                                                                                 sprint(self, "^1You cannot change team, forbidden by the server.\n");
539                                                                         else
540                                                                         {
541                                                                                 if(autocvar_g_balance_teams && autocvar_g_balance_teams_prevent_imbalance)
542                                                                                 {
543                                                                                         CheckAllowedTeams(self);
544                                                                                         GetTeamCounts(self);
545                                                                                         if(!TeamSmallerEqThanTeam(Team_TeamToNumber(selection), Team_TeamToNumber(self.team), self))
546                                                                                         {
547                                                                                                 Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TEAMCHANGE_LARGERTEAM);
548                                                                                                 return;
549                                                                                         }
550                                                                                 }
551                                                                                 ClientKill_TeamChange(selection);
552                                                                         }
553                                                                 }
554                                                         }
555                                                         else
556                                                                 sprint(self, "^7The game has already begun, you must wait until the next map to be able to join a team.\n");
557                                                 else
558                                                         sprint(self, "^7selectteam can not be used as your team is forced\n");
559                                         else
560                                                 sprint(self, "^7selectteam can only be used in teamgames\n");
561                                 }
562                                 return;
563                         }
564                 }
565
566                 default:
567                         sprint(self, "Incorrect parameters for ^2selectteam^7\n");
568                 case CMD_REQUEST_USAGE:
569                 {
570                         sprint(self, "\nUsage:^3 cmd selectteam team\n");
571                         sprint(self, "  Where 'team' is the prefered team to try and join.\n");
572                         sprint(self, "  Full list of options here: \"red, blue, yellow, pink, auto\"\n");
573                         return;
574                 }
575         }
576 }
577
578 void ClientCommand_selfstuff(float request, string command)
579 {
580         switch(request)
581         {
582                 case CMD_REQUEST_COMMAND:
583                 {
584                         if(argv(1) != "")
585                         {
586                                 stuffcmd(self, substring(command, argv_start_index(1), argv_end_index(-1) - argv_start_index(1)));
587                                 return;
588                         }
589                 }
590
591                 default:
592                         sprint(self, "Incorrect parameters for ^2selectteam^7\n");
593                 case CMD_REQUEST_USAGE:
594                 {
595                         sprint(self, "\nUsage:^3 cmd selfstuff <command>\n");
596                         sprint(self, "  Where 'command' is the string to be stuffed to your client.\n");
597                         return;
598                 }
599         }
600 }
601
602 void ClientCommand_sentcvar(float request, float argc, string command)
603 {
604         switch(request)
605         {
606                 case CMD_REQUEST_COMMAND:
607                 {
608                         if(argv(1) != "")
609                         {
610                                 //float tokens;
611                                 string s;
612
613                                 if(argc == 2) // undefined cvar: use the default value on the server then
614                                 {
615                                         s = strcat(substring(command, argv_start_index(0), argv_end_index(1) - argv_start_index(0)), " \"", cvar_defstring(argv(1)), "\"");
616                                         tokenize_console(s);
617                                 }
618
619                                 GetCvars(1);
620
621                                 return;
622                         }
623                 }
624
625                 default:
626                         sprint(self, "Incorrect parameters for ^2sentcvar^7\n");
627                 case CMD_REQUEST_USAGE:
628                 {
629                         sprint(self, "\nUsage:^3 cmd sentcvar <cvar>\n");
630                         sprint(self, "  Where 'cvar' is the cvar plus arguments to send to the server.\n");
631                         return;
632                 }
633         }
634 }
635
636 void ClientCommand_spectate(float request)
637 {
638         switch(request)
639         {
640                 case CMD_REQUEST_COMMAND:
641                 {
642                         if(IS_CLIENT(self))
643                         {
644                                 if(g_lms)
645                                 {
646                                         if(self.lms_spectate_warning)
647                                         {
648                                                 // for the forfeit message...
649                                                 self.lms_spectate_warning = 2;
650                                                 // mark player as spectator
651                                                 PlayerScore_Add(self, SP_LMS_RANK, 666 - PlayerScore_Add(self, SP_LMS_RANK, 0));
652                                         }
653                                         else
654                                         {
655                                                 self.lms_spectate_warning = 1;
656                                                 sprint(self, "WARNING: you won't be able to enter the game again after spectating in LMS. Use the same command again to spectate anyway.\n");
657                                                 return;
658                                         }
659                                 }
660
661                                 if((IS_PLAYER(self) || self.caplayer) && autocvar_sv_spectate == 1)
662                                 {
663                                         if(self.caplayer && (IS_SPEC(self) || IS_OBSERVER(self)))
664                                                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_CA_LEAVE);
665                                         ClientKill_TeamChange(-2); // observe
666                                 }
667                         }
668                         return; // never fall through to usage
669                 }
670
671                 default:
672                 case CMD_REQUEST_USAGE:
673                 {
674                         sprint(self, "\nUsage:^3 cmd spectate\n");
675                         sprint(self, "  No arguments required.\n");
676                         return;
677                 }
678         }
679 }
680
681 void ClientCommand_suggestmap(float request, float argc)
682 {
683         switch(request)
684         {
685                 case CMD_REQUEST_COMMAND:
686                 {
687                         if(argv(1) != "")
688                         {
689                                 sprint(self, strcat(MapVote_Suggest(argv(1)), "\n"));
690                                 return;
691                         }
692                 }
693
694                 default:
695                         sprint(self, "Incorrect parameters for ^2suggestmap^7\n");
696                 case CMD_REQUEST_USAGE:
697                 {
698                         sprint(self, "\nUsage:^3 cmd suggestmap map\n");
699                         sprint(self, "  Where 'map' is the name of the map to suggest.\n");
700                         return;
701                 }
702         }
703 }
704
705 void ClientCommand_tell(float request, float argc, string command)
706 {
707         switch(request)
708         {
709                 case CMD_REQUEST_COMMAND:
710                 {
711                         if(argc >= 3)
712                         {
713                                 entity tell_to = GetIndexedEntity(argc, 1);
714                                 float tell_accepted = VerifyClientEntity(tell_to, true, false);
715
716                                 if(tell_accepted > 0) // the target is a real client
717                                 {
718                                         if(tell_to != self) // and we're allowed to send to them :D
719                                         {
720                                                 Say(self, false, tell_to, substring(command, argv_start_index(next_token), argv_end_index(-1) - argv_start_index(next_token)), true);
721                                                 return;
722                                         }
723                                         else { print_to(self, "You can't ^2tell^7 a message to yourself."); return; }
724                                 }
725                                 else if(argv(1) == "#0")
726                                 {
727                                         trigger_magicear_processmessage_forallears(self, -1, world, substring(command, argv_start_index(next_token), argv_end_index(-1) - argv_start_index(next_token)));
728                                         return;
729                                 }
730                                 else { print_to(self, strcat("tell: ", GetClientErrorString(tell_accepted, argv(1)), ".")); return; }
731                         }
732                 }
733
734                 default:
735                         sprint(self, "Incorrect parameters for ^2tell^7\n");
736                 case CMD_REQUEST_USAGE:
737                 {
738                         sprint(self, "\nUsage:^3 cmd tell client <message>\n");
739                         sprint(self, "  Where 'client' is the entity number or name of the player to send 'message' to.\n");
740                         return;
741                 }
742         }
743 }
744
745 void ClientCommand_voice(float request, float argc, string command)
746 {
747         switch(request)
748         {
749                 case CMD_REQUEST_COMMAND:
750                 {
751                         if(argv(1) != "")
752                         {
753                                 if(argc >= 3)
754                                         VoiceMessage(argv(1), substring(command, argv_start_index(2), argv_end_index(-1) - argv_start_index(2)));
755                                 else
756                                         VoiceMessage(argv(1), "");
757
758                                 return;
759                         }
760                 }
761
762                 default:
763                         sprint(self, "Incorrect parameters for ^2voice^7\n");
764                 case CMD_REQUEST_USAGE:
765                 {
766                         sprint(self, "\nUsage:^3 cmd voice messagetype <soundname>\n");
767                         sprint(self, "  'messagetype' is the type of broadcast to do, like team only or such,\n");
768                         sprint(self, "  and 'soundname' is the string/filename of the sound/voice message to play.\n");
769                         return;
770                 }
771         }
772 }
773
774 /* use this when creating a new command, making sure to place it in alphabetical order... also,
775 ** ADD ALL NEW COMMANDS TO commands.cfg WITH PROPER ALIASES IN THE SAME FASHION!
776 void ClientCommand_(float request)
777 {
778         switch(request)
779         {
780                 case CMD_REQUEST_COMMAND:
781                 {
782
783                         return; // never fall through to usage
784                 }
785
786                 default:
787                 case CMD_REQUEST_USAGE:
788                 {
789                         sprint(self, "\nUsage:^3 cmd \n");
790                         sprint(self, "  No arguments required.\n");
791                         return;
792                 }
793         }
794 }
795 */
796
797
798 // =====================================
799 //  Macro system for networked commands
800 // =====================================
801
802 // Do not hard code aliases for these, instead create them in commands.cfg... also: keep in alphabetical order, please ;)
803 #define CLIENT_COMMANDS(request,arguments,command) \
804         CLIENT_COMMAND("autoswitch", ClientCommand_autoswitch(request, arguments), "Whether or not to switch automatically when getting a better weapon") \
805         CLIENT_COMMAND("checkfail", ClientCommand_checkfail(request, command), "Report if a client-side check failed") \
806         CLIENT_COMMAND("clientversion", ClientCommand_clientversion(request, arguments), "Release version of the game") \
807         CLIENT_COMMAND("mv_getpicture", ClientCommand_mv_getpicture(request, arguments), "Retrieve mapshot picture from the server") \
808         CLIENT_COMMAND("join", ClientCommand_join(request), "Become a player in the game") \
809         CLIENT_COMMAND("mobedit", ClientCommand_mobedit(request, arguments), "Edit your monster's properties") \
810         CLIENT_COMMAND("mobkill", ClientCommand_mobkill(request), "Kills your monster") \
811         CLIENT_COMMAND("mobspawn", ClientCommand_mobspawn(request, arguments), "Spawn monsters infront of yourself") \
812         CLIENT_COMMAND("physics", ClientCommand_physics(request, arguments), "Change physics set") \
813         CLIENT_COMMAND("ready", ClientCommand_ready(request), "Qualify as ready to end warmup stage (or restart server if allowed)") \
814         CLIENT_COMMAND("say", ClientCommand_say(request, arguments, command), "Print a message to chat to all players") \
815         CLIENT_COMMAND("say_team", ClientCommand_say_team(request, arguments, command), "Print a message to chat to all team mates") \
816         CLIENT_COMMAND("selectteam", ClientCommand_selectteam(request, arguments), "Attempt to choose a team to join into") \
817         CLIENT_COMMAND("selfstuff", ClientCommand_selfstuff(request, command), "Stuffcmd a command to your own client") \
818         CLIENT_COMMAND("sentcvar", ClientCommand_sentcvar(request, arguments, command), "New system for sending a client cvar to the server") \
819         CLIENT_COMMAND("spectate", ClientCommand_spectate(request), "Become an observer") \
820         CLIENT_COMMAND("suggestmap", ClientCommand_suggestmap(request, arguments), "Suggest a map to the mapvote at match end") \
821         CLIENT_COMMAND("tell", ClientCommand_tell(request, arguments, command), "Send a message directly to a player") \
822         CLIENT_COMMAND("voice", ClientCommand_voice(request, arguments, command), "Send voice message via sound") \
823         /* nothing */
824
825 void ClientCommand_macro_help()
826 {
827         #define CLIENT_COMMAND(name,function,description) \
828                 { sprint(self, "  ^2", name, "^7: ", description, "\n"); }
829
830         CLIENT_COMMANDS(0, 0, "");
831         #undef CLIENT_COMMAND
832
833         return;
834 }
835
836 float ClientCommand_macro_command(float argc, string command)
837 {
838         #define CLIENT_COMMAND(name,function,description) \
839                 { if(name == strtolower(argv(0))) { function; return true; } }
840
841         CLIENT_COMMANDS(CMD_REQUEST_COMMAND, argc, command);
842         #undef CLIENT_COMMAND
843
844         return false;
845 }
846
847 float ClientCommand_macro_usage(float argc)
848 {
849         #define CLIENT_COMMAND(name,function,description) \
850                 { if(name == strtolower(argv(1))) { function; return true; } }
851
852         CLIENT_COMMANDS(CMD_REQUEST_USAGE, argc, "");
853         #undef CLIENT_COMMAND
854
855         return false;
856 }
857
858 void ClientCommand_macro_write_aliases(float fh)
859 {
860         #define CLIENT_COMMAND(name,function,description) \
861                 { CMD_Write_Alias("qc_cmd_cmd", name, description); }
862
863         CLIENT_COMMANDS(0, 0, "");
864         #undef CLIENT_COMMAND
865
866         return;
867 }
868
869 // ======================================
870 //  Main Function Called By Engine (cmd)
871 // ======================================
872 // If this function exists, server game code parses clientcommand before the engine code gets it.
873
874 void SV_ParseClientCommand(string command)
875 {
876         // If invalid UTF-8, don't even parse it
877         string command2 = "";
878         float len = strlen(command);
879         float i;
880         for (i = 0; i < len; ++i)
881                 command2 = strcat(command2, chr2str(str2chr(command, i)));
882         if (command != command2)
883                 return;
884
885         // if we're banned, don't even parse the command
886         if(Ban_MaybeEnforceBanOnce(self))
887                 return;
888
889         float argc = tokenize_console(command);
890
891         // Guide for working with argc arguments by example:
892         // argc:   1    - 2      - 3     - 4
893         // argv:   0    - 1      - 2     - 3
894         // cmd     vote - master - login - password
895
896         // for floodcheck
897         switch(strtolower(argv(0)))
898         {
899                 // exempt commands which are not subject to floodcheck
900                 case "begin": break; // handled by engine in host_cmd.c
901                 case "download": break; // handled by engine in cl_parse.c
902                 case "mv_getpicture": break; // handled by server in this file
903                 case "pause": break; // handled by engine in host_cmd.c
904                 case "prespawn": break; // handled by engine in host_cmd.c
905                 case "sentcvar": break; // handled by server in this file
906                 case "spawn": break; // handled by engine in host_cmd.c
907
908                 default:
909                         if(SV_ParseClientCommand_floodcheck())
910                                 break; // "true": continue, as we're not flooding yet
911                         else
912                                 return; // "false": not allowed to continue, halt // print("^1ERROR: ^7ANTISPAM CAUGHT: ", command, ".\n");
913         }
914
915         /* NOTE: should this be disabled? It can be spammy perhaps, but hopefully it's okay for now */
916         if(argv(0) == "help")
917         {
918                 if(argc == 1)
919                 {
920                         sprint(self, "\nClient networked commands:\n");
921                         ClientCommand_macro_help();
922
923                         sprint(self, "\nCommon networked commands:\n");
924                         CommonCommand_macro_help(self);
925
926                         sprint(self, "\nUsage:^3 cmd COMMAND...^7, where possible commands are listed above.\n");
927                         sprint(self, "For help about a specific command, type cmd help COMMAND\n");
928                         return;
929                 }
930                 else if(CommonCommand_macro_usage(argc, self)) // Instead of trying to call a command, we're going to see detailed information about it
931                 {
932                         return;
933                 }
934                 else if(ClientCommand_macro_usage(argc)) // same, but for normal commands now
935                 {
936                         return;
937                 }
938         }
939         else if(MUTATOR_CALLHOOK(SV_ParseClientCommand, strtolower(argv(0)), argc, command))
940         {
941                 return; // handled by a mutator
942         }
943         else if(CheatCommand(argc))
944         {
945                 return; // handled by server/cheats.qc
946         }
947         else if(CommonCommand_macro_command(argc, self, command))
948         {
949                 return; // handled by server/command/common.qc
950         }
951         else if(ClientCommand_macro_command(argc, command)) // continue as usual and scan for normal commands
952         {
953                 return; // handled by one of the above ClientCommand_* functions
954         }
955         else
956                 clientcommand(self, command);
957 }