+// =====================================================
+// Server side game commands code, reworked by Samual
+// Last updated: July 22nd, 2011
+// =====================================================
+
+#define GC_REQUEST_HELP 1
+#define GC_REQUEST_COMMAND 2
+#define GC_REQUEST_USAGE 3
+
+entity radarmapper;
+
+float RADAR_WIDTH_MAX = 512;
+float RADAR_HEIGHT_MAX = 512;
+float sharpen_buffer[RADAR_WIDTH_MAX * 3];
+
string GotoMap(string m);
+string doublehex = "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFFFF";
+// FF is contained twice, to map 256 to FF too
+// removes the need to bound()
+
void race_deleteTime(string map, float pos);
+
+// ============================
+// Misc. Supporting Functions
+// ============================
+
+// used by GameCommand_radarmap()
float FullTraceFraction(vector a, vector mi, vector ma, vector b)
{
vector c;
return white / (black + white);
}
-
float RadarMapAtPoint_Trace(float x, float y, float w, float h, float zmin, float zsize, float q)
{
vector a, b, mi, ma;
return c / q;
}
-
-// FF is contained twice, to map 256 to FF too
-// removes the need to bound()
-string doublehex = "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFFFF";
-
-float RADAR_WIDTH_MAX = 512;
-float RADAR_HEIGHT_MAX = 512;
-float sharpen_buffer[RADAR_WIDTH_MAX * 3];
-
void sharpen_set(float x, float v)
{
sharpen_buffer[x + 2 * RADAR_WIDTH_MAX] = v;
}
-
float sharpen_getpixel(float x, float y)
{
if(x < 0)
return 0;
return sharpen_buffer[x + y * RADAR_WIDTH_MAX];
}
-
float sharpen_get(float x, float a)
{
float sum;
sum -= sharpen_getpixel(x, 2);
return bound(0, sum * a, 1);
}
-
void sharpen_shift(float w)
{
float i;
sharpen_buffer[i + 2 * RADAR_WIDTH_MAX] = 0;
}
}
-
void sharpen_init(float w)
{
float i;
sharpen_buffer[i + 2 * RADAR_WIDTH_MAX] = 0;
}
}
-
-entity radarmapper;
void RadarMap_Next()
{
if(radarmapper.count & 4)
remove(radarmapper);
radarmapper = world;
}
-
-// rough map entity
-// cnt: current line
-// size: pixel width/height
-// maxs: cell width/height
-// frame: counter
void RadarMap_Think()
{
+ // rough map entity
+ // cnt: current line
+ // size: pixel width/height
+ // maxs: cell width/height
+ // frame: counter
+
float i, x, l;
string si;
}
}
-void RadarMap(float argc)
-{
- if(radarmapper)
- return;
- float i;
- radarmapper = spawn();
- radarmapper.classname = "radarmapper";
- radarmapper.think = RadarMap_Think;
- radarmapper.nextthink = time;
- radarmapper.count = 8; // default to the --trace method, as it is faster now
- radarmapper.ltime = 1;
- radarmapper.size_x = 512;
- radarmapper.size_y = 512;
- radarmapper.size_z = 1;
-
- for(i = 1; i < argc; ++i)
- {
- if(argv(i) == "--force")
- radarmapper.count |= 1;
- else if(argv(i) == "--loop")
- radarmapper.count |= 2;
- else if(argv(i) == "--quit")
- radarmapper.count |= 4;
- else if(argv(i) == "--block")
- {
- radarmapper.count &~= 24;
- }
- else if(argv(i) == "--trace")
- {
- radarmapper.count &~= 24;
- radarmapper.count |= 8;
- }
- else if(argv(i) == "--sample")
- {
- radarmapper.count &~= 24;
- radarmapper.count |= 16;
- }
- else if(argv(i) == "--lineblock")
- {
- radarmapper.count |= 24;
- }
- else if(argv(i) == "--flags") // for the recursive call
- {
- ++i;
- radarmapper.count = stof(argv(i));
- }
- else if(argv(i) == "--sharpen") // for the recursive call
- {
- ++i;
- radarmapper.ltime = stof(argv(i));
- }
- else if(argv(i) == "--res") // resolution
- {
- ++i;
- radarmapper.size_x = stof(argv(i));
- ++i;
- radarmapper.size_y = stof(argv(i));
- }
- else if(argv(i) == "--qual") // quality multiplier
- {
- ++i;
- radarmapper.size_z = stof(argv(i));
- }
- else
- {
- remove(radarmapper);
- radarmapper = world;
- print("Usage: sv_cmd radarmap [--force] [--loop] [--quit] [--block | --trace | --sample | --lineblock] [--sharpen N] [--res W H] [--qual Q]\n");
- print("The quality factor Q is roughly proportional to the time taken.\n");
- print("--trace supports no quality factor; its result should look like --block with infinite quality factor.\n");
- print("--block \n");
- return;
- }
- }
-
- print("Radarmap entity spawned.\n");
-}
-
+// used by GameCommand_make_mapinfo()
void make_mapinfo_Think()
{
if(MapInfo_FilterGametype(MAPINFO_TYPE_ALL, 0, 0, 0, 1))
}
}
+// used by GameCommand_extendmatchtime() and GameCommand_reducematchtime()
void changematchtime(float delta, float mi, float ma)
{
float cur;
cvar_set("timelimit", ftos(new / 60));
}
+// used by GameCommand_modelbug() // TODO: is this even needed?
float g_clientmodel_genericsendentity (entity to, float sf);
void modelbug_make_svqc();
void modelbug_make_csqc()
self.nextthink = time + 1;
setorigin(self, self.origin + '0 0 8');
}
-
void modelbug()
{
entity e;
e.nextthink = time + 1;
}
-// ===================
-// Command Functions
-// ===================
-#define GC_REQUEST_HELP 1
-#define GC_REQUEST_COMMAND 2
-#define GC_REQUEST_USAGE 3
-void GameCommand_adminmsg(float request, string command)
+// =======================
+// Command Sub-Functions
+// =======================
+
+void GameCommand_adminmsg(float request, float argc)
{
entity client;
- float argc = tokenize_console(command);
float entno = stof(argv(1));
float n, i;
string s;
switch(request)
{
case GC_REQUEST_HELP:
- print(" adminmsg - Send an admin message to a client directly\n");
+ print(" ^2adminmsg^7: Send an admin message to a client directly\n");
return;
case GC_REQUEST_COMMAND:
{
if(argc == 4)
{
+ // make the string console safe
s = argv(2);
s = strreplace("\n", "", s);
s = strreplace("\\", "\\\\", s);
}
else
{
- centerprint_atprio(client, CENTERPRIO_ADMIN, strcat("^3", admin_name(), ":\n\n^7", argv(2)));
+ centerprint(client, strcat("^3", admin_name(), ":\n\n^7", argv(2)));
sprint(client, strcat("\{1}\{13}^3", admin_name(), "^7: ", argv(2), "\n"));
}
dprint("Message sent to ", client.netname, "\n");
++n;
}
}
- if(!n) { print("Client not found\n"); }
+ if(!n) { print(strcat("Client (", argv(1) ,") not found.\n")); }
return;
}
default:
- print("Incorrect parameters for \"adminmsg\"\n");
+ print("Incorrect parameters for ^2adminmsg^7\n");
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd adminmsg clientnumber \"message\" [infobartime]\n");
+ print("\nUsage:^3 sv_cmd adminmsg clientnumber \"message\" [infobartime]\n");
print(" If infobartime is provided, the message will be sent to infobar.\n");
print(" Otherwise, it will just be sent as a centerprint message.\n");
- print("Examples: adminmsg 4 \"this message will last for ten seconds\" 10\n");
+ print("Examples: adminmsg 4 \"this infomessage will last for ten seconds\" 10\n");
print(" adminmsg 2 \"this message will be a centerprint\"\n");
return;
}
switch(request)
{
case GC_REQUEST_HELP:
- print(" allready - Restart the server and reset the players\n");
+ print(" ^2allready^7: Restart the server and reset the players\n");
return;
case GC_REQUEST_COMMAND:
default:
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd allready\n");
+ print("\nUsage:^3 sv_cmd allready\n");
print(" No arguments required.\n");
return;
}
}
-void GameCommand_allspec(float request) // todo: Add ability to provide a reason string
+void GameCommand_allspec(float request, float argc)
{
entity client;
float i;
+
switch(request)
{
case GC_REQUEST_HELP:
- print(" allspec - Force all players to spectate\n");
+ print(" ^2allspec^7: Force all players to spectate\n");
return;
case GC_REQUEST_COMMAND:
FOR_EACH_PLAYER(client)
{
+ self = client;
PutObserverInServer();
++i;
}
- if(i) { bprint(strcat("Successfully forced all players to spectate (", ftos(i), ")\n")); } // should a message be added if no players were found?
+ if(i) { bprint(strcat("Successfully forced all (", ftos(i), ") players to spectate", (argv(1) ? strcat(" for reason: '", argv(1), "'") : ""), ".\n")); }
+ else { print("No players found to spectate.\n"); }
return;
default:
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd allspec\n");
- print(" No arguments required.\n");
+ print("\nUsage:^3 sv_cmd allspec [reason]\n");
+ print(" Where 'reason' is an optional argument for explanation of allspec command.\n");
+ print("See also: ^2moveplayer^7\n");
return;
}
}
-void GameCommand_anticheat(float request, string command) // FIXME: player entity is never found
+void GameCommand_anticheat(float request, float argc) // FIXME: player entity is never found
{
entity client;
- float argc = tokenize_console(command);
float entno = stof(argv(1));
switch(request)
{
case GC_REQUEST_HELP:
- print(" anticheat - Create an anticheat report for a client\n");
+ print(" ^2anticheat^7: Create an anticheat report for a client\n");
return;
case GC_REQUEST_COMMAND:
return;
default:
- print("Incorrect parameters for \"anticheat\"\n");
+ print("Incorrect parameters for ^2anticheat^7\n");
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd anticheat clientnumber\n");
- print(" where clientnumber is player entity number.\n");
+ print("\nUsage:^3 sv_cmd anticheat clientnumber\n");
+ print(" where 'clientnumber' is player entity number.\n");
return;
}
}
switch(request)
{
case GC_REQUEST_HELP:
- print(" bbox - Print detailed information about world size\n");
+ print(" ^2bbox^7: Print detailed information about world size\n");
return;
case GC_REQUEST_COMMAND:
default:
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd bbox\n");
+ print("\nUsage:^3 sv_cmd bbox\n");
print(" No arguments required.\n");
+ print("See also: ^2gettaginfo^7\n");
return;
}
}
-void GameCommand_bot_cmd(float request, string command) // what a mess... old old code.
+void GameCommand_bot_cmd(float request, float argc) // what a mess... old old code.
{
entity bot;
- float argc = tokenize_console(command);
switch(request)
{
case GC_REQUEST_HELP:
- print(" bot_cmd - Control and send commands to bots\n");
+ print(" ^2bot_cmd^7: Control and send commands to bots\n");
return;
case GC_REQUEST_COMMAND:
}
default:
- print("Incorrect parameters for \"bot_cmd\"\n");
+ print("Incorrect parameters for ^2bot_cmd^7\n");
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd bot_cmd client command [argument]\n");
+ print("\nUsage:^3 sv_cmd bot_cmd client command [argument]\n");
print(" 'client' can be either the name or entity id of the bot\n");
print(" For full list of commands, see bot_cmd help [command].\n");
print("Examples: bot_cmd <id> cc \"say something\"\n");
}
}
-void GameCommand_cointoss(float request) // todo: Perhaps add the ability to give your own arguments to pick between? (Like player names)
+void GameCommand_cointoss(float request, float argc)
{
entity client;
- float choice = (random() > 0.5);
+ string result1 = (argv(2) ? strcat("^7", argv(1), "^3!\n") : "^1HEADS^3!\n");
+ string result2 = (argv(2) ? strcat("^7", argv(2), "^3!\n") : "^4TAILS^3!\n");
+ string choice = ((random() > 0.5) ? result1 : result2);
switch(request)
{
case GC_REQUEST_HELP:
- print(" cointoss - Flip a virtual coin and give random result\n");
+ print(" ^2cointoss^7: Flip a virtual coin and give random result\n");
return;
case GC_REQUEST_COMMAND:
FOR_EACH_CLIENT(client)
- centerprint(client, strcat("^3Throwing coin... Result: ", (choice ? "^1HEADS^3!\n" : "^4TAILS^3!\n")));
- bprint(strcat("^3Throwing coin... Result: ", (choice ? "^1HEADS^3!\n" : "^4TAILS^3!\n")));
+ centerprint(client, strcat("^3Throwing coin... Result: ", choice));
+ bprint(strcat("^3Throwing coin... Result: ", choice));
return;
default:
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd cointoss\n");
- print(" No arguments required.\n");
+ print("\nUsage:^3 sv_cmd cointoss [result1 result2]\n");
+ print(" Where 'result1' and 'result2' are user created options.\n");
return;
}
}
switch(request)
{
case GC_REQUEST_HELP:
- print(" cvar_changes - Prints a list of all changed server cvars\n");
+ print(" ^2cvar_changes^7: Prints a list of all changed server cvars\n");
return;
case GC_REQUEST_COMMAND:
default:
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd \n");
+ print("\nUsage:^3 sv_cmd cvar_changes\n");
print(" No arguments required.\n");
+ print("See also: ^2cvar_purechanges^7\n");
return;
}
}
switch(request)
{
case GC_REQUEST_HELP:
- print(" cvar_purechanges - Prints a list of all changed gameplay cvars\n");
+ print(" ^2cvar_purechanges^7: Prints a list of all changed gameplay cvars\n");
return;
case GC_REQUEST_COMMAND:
default:
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd cvar_purechanges\n");
+ print("\nUsage:^3 sv_cmd cvar_purechanges\n");
print(" No arguments required.\n");
+ print("See also: ^2cvar_changes^7\n");
return;
}
}
-void GameCommand_database(float request, string command)
+void GameCommand_database(float request, float argc)
{
- float argc = tokenize_console(command);
-
switch(request)
{
case GC_REQUEST_HELP:
- print(" database - Extra controls of the serverprogs database\n");
+ print(" ^2database^7: Extra controls of the serverprogs database\n");
return;
case GC_REQUEST_COMMAND:
}
default:
- print("Incorrect parameters for \"database\"\n");
+ print("Incorrect parameters for ^2database^7\n");
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd database action filename\n");
- print(" Where action is the command to complete,\n");
- print(" and filename is what it acts upon.\n");
+ print("\nUsage:^3 sv_cmd database action filename\n");
+ print(" Where 'action' is the command to complete,\n");
+ print(" and 'filename' is what it acts upon.\n");
print(" Full list of commands here: \"save, dump, load.\"\n");
return;
}
}
-void GameCommand_defer_clear(float request, string command)
+void GameCommand_defer_clear(float request, float argc)
{
entity client;
- float argc = tokenize_console(command);
float entno = stof(argv(1));
switch(request)
{
case GC_REQUEST_HELP:
- print(" defer_clear - Clear all queued defer commands for client\n");
+ print(" ^2defer_clear^7: Clear all queued defer commands for client\n");
return;
case GC_REQUEST_COMMAND:
}
default:
- print("Incorrect parameters for \"defer_clear\"\n");
+ print("Incorrect parameters for ^2defer_clear^7\n");
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd defer_clear clientnumber\n");
- print(" where clientnumber is player entity number.\n");
+ print("\nUsage:^3 sv_cmd defer_clear clientnumber\n");
+ print(" where 'clientnumber' is player entity number.\n");
+ print("See also: ^2defer_clear_all^7\n");
return;
}
}
{
entity client;
float i;
+ float argc;
switch(request)
{
case GC_REQUEST_HELP:
- print(" defer_clear_all - Clear all queued defer commands for all clients\n");
+ print(" ^2defer_clear_all^7: Clear all queued defer commands for all clients\n");
return;
case GC_REQUEST_COMMAND:
FOR_EACH_CLIENT(client)
{
- GameCommand_defer_clear(GC_REQUEST_COMMAND, strcat("defer_clear ", ftos(num_for_edict(client))));
+ argc = tokenize_console(strcat("defer_clear ", ftos(num_for_edict(client))));
+ GameCommand_defer_clear(GC_REQUEST_COMMAND, argc);
++i;
}
if(i) { bprint(strcat("Successfully stuffed defer clear to all clients (", ftos(i), ")\n")); } // should a message be added if no players were found?
default:
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd defer_clear_all\n");
+ print("\nUsage:^3 sv_cmd defer_clear_all\n");
print(" No arguments required.\n");
+ print("See also: ^2defer_clear^7\n");
return;
}
}
-void GameCommand_delrec(float request, string command) // UNTESTED
+void GameCommand_delrec(float request, float argc) // UNTESTED // perhaps merge later with records and printstats and such?
{
- float argc = tokenize_console(command);
-
switch(request)
{
case GC_REQUEST_HELP:
- print(" delrec - Delete race time record for a map\n");
+ print(" ^2delrec^7: Delete race time record for a map\n");
return;
case GC_REQUEST_COMMAND:
}
default:
- print("Incorrect parameters for \"delrec\"\n");
+ print("Incorrect parameters for ^2delrec^7\n");
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd delrec ranking [map]\n");
- print(" ranking is which ranking level to clear up to, \n");
+ print("\nUsage:^3 sv_cmd delrec ranking [map]\n");
+ print(" 'ranking' is which ranking level to clear up to, \n");
print(" it will clear all records up to nth place.\n");
- print(" if map is not provided it will use current map.\n");
+ print(" if 'map' is not provided it will use current map.\n");
return;
}
}
switch(request)
{
case GC_REQUEST_HELP:
- print(" effectindexdump - Dump list of effects from code and effectinfo.txt\n");
+ print(" ^2effectindexdump^7: Dump list of effects from code and effectinfo.txt\n");
return;
case GC_REQUEST_COMMAND:
default:
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd effectindexdump\n");
+ print("\nUsage:^3 sv_cmd effectindexdump\n");
print(" No arguments required.\n");
return;
}
}
-void GameCommand_extendmatchtime(float request) // todo: Perhaps allows the user to send a specific time to extend it.
+void GameCommand_extendmatchtime(float request)
{
switch(request)
{
case GC_REQUEST_HELP:
- print(" extendmatchtime - Increase the timelimit value incrementally\n");
+ print(" ^2extendmatchtime^7: Increase the timelimit value incrementally\n");
return;
case GC_REQUEST_COMMAND:
default:
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd extendmatchtime\n");
+ print("\nUsage:^3 sv_cmd extendmatchtime\n");
print(" No arguments required.\n");
+ print("See also: ^2reducematchtime^7\n");
return;
}
}
-void GameCommand_find(float request, string command)
+void GameCommand_find(float request, float argc)
{
entity client;
- float argc = tokenize_console(command);
switch(request)
{
case GC_REQUEST_HELP:
- print(" find - Search through entities for matching classname\n");
+ print(" ^2find^7: Search through entities for matching classname\n");
return;
case GC_REQUEST_COMMAND:
return;
default:
- print("Incorrect parameters for \"find\"\n");
+ print("Incorrect parameters for ^2find^7\n");
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd find classname\n");
- print(" Where classname is the classname to search for.\n");
+ print("\nUsage:^3 sv_cmd find classname\n");
+ print(" Where 'classname' is the classname to search for.\n");
return;
}
}
-void GameCommand_gametype(float request, string command)
+void GameCommand_gametype(float request, float argc)
{
- float argc = tokenize_console(command);
string s = argv(1);
float t = MapInfo_Type_FromString(s), tsave = MapInfo_CurrentGametype();
switch(request)
{
case GC_REQUEST_HELP:
- print(" gametype - Simple command to change the active gametype\n");
+ print(" ^2gametype^7: Simple command to change the active gametype\n");
return;
case GC_REQUEST_COMMAND:
return;
default:
- print("Incorrect parameters for \"gametype\"\n");
+ print("Incorrect parameters for ^2gametype^7\n");
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd gametype mode\n");
- print(" Where mode is the gametype mode to switch to.\n");
+ print("\nUsage:^3 sv_cmd gametype mode\n");
+ print(" Where 'mode' is the gametype mode to switch to.\n");
+ print("See also: ^2gotomap^7\n");
return;
}
}
-void GameCommand_gettaginfo(float request, string command) // UNTESTED // todo: finish usage description for it (but, must first learn this shit)
+void GameCommand_gettaginfo(float request, float argc) // UNTESTED // todo: finish usage description for it (but, must first learn this shit)
{
entity tmp_entity;
- float argc = tokenize_console(command), i;
+ float i;
vector v;
+
switch(request)
{
case GC_REQUEST_HELP:
- print(" gettaginfo - Get specific information about a weapon model\n");
+ print(" ^2gettaginfo^7: Get specific information about a weapon model\n");
return;
case GC_REQUEST_COMMAND:
}
default:
- print("Incorrect parameters for \"gettaginfo\"\n");
+ print("Incorrect parameters for ^2gettaginfo^7\n");
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd gettaginfo\n");
+ print("\nUsage:^3 sv_cmd gettaginfo\n");
print(" FIXME: Arguments currently unknown\n");
+ print("See also: ^2bbox^7\n");
return;
}
}
-void GameCommand_gotomap(float request, string command)
+void GameCommand_gotomap(float request, float argc)
{
- float argc = tokenize_console(command);
-
switch(request)
{
case GC_REQUEST_HELP:
- print(" gotomap - Simple command to switch to another map\n");
+ print(" ^2gotomap^7: Simple command to switch to another map\n");
return;
case GC_REQUEST_COMMAND:
}
default:
+ print("Incorrect parameters for ^2gotomap^7\n");
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd gotomap map\n");
- print(" Where map is the *.bsp file to change to.\n");
+ print("\nUsage:^3 sv_cmd gotomap map\n");
+ print(" Where 'map' is the *.bsp file to change to.\n");
+ print("See also: ^2gametype^7\n");
return;
}
}
switch(request)
{
case GC_REQUEST_HELP:
- print(" ladder - Get information about top players if supported\n");
+ print(" ^2ladder^7: Get information about top players if supported\n");
return;
case GC_REQUEST_COMMAND:
default:
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd ladder\n");
+ print("\nUsage:^3 sv_cmd ladder\n");
print(" No arguments required.\n");
return;
}
switch(request)
{
case GC_REQUEST_HELP:
- print(" lockteams - Disable the ability for players to switch or enter teams\n");
+ print(" ^2lockteams^7: Disable the ability for players to switch or enter teams\n");
return;
case GC_REQUEST_COMMAND:
default:
case GC_REQUEST_USAGE:
- print("\nUsage: sv_cmd lockteams\n");
+ print("\nUsage:^3 sv_cmd lockteams\n");
print(" No arguments required.\n");
+ print("See also: ^2unlockteams^7\n");
return;
}
}
-void GameCommand(string command)
+void GameCommand_make_mapinfo(float request) // UNTESTED
{
- // ===== TODO list =====
+ entity tmp_entity;
- // Finish adding the rest of the commands
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2make_mapinfo^7: Automatically rebuild mapinfo files\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ tmp_entity = spawn();
+ tmp_entity.classname = "make_mapinfo";
+ tmp_entity.think = make_mapinfo_Think;
+ tmp_entity.nextthink = time; // this sucks... todo: re-write this -- Use initializeentity later
+ MapInfo_Enumerate();
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd make_mapinfo\n");
+ print(" No arguments required.\n");
+ return;
+ }
+}
+
+void GameCommand_modelbug(float request) // UNTESTED // is this even needed anymore?
+{
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2modelbug^7: foobar\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ modelbug();
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd modelbug\n");
+ print(" No arguments required.\n");
+ return;
+ }
+}
+
+void GameCommand_moveplayer(float request, float argc)
+{
+ entity client;
+ string targets = argv(1);
+ string destination = argv(2);
+ string notify = argv(3);
+ float i;
+ argc = tokenizebyseparator(targets, ","); // re-use argc for the targets
+
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2moveplayer^7: Change the team/status of a player\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ // lets see if the target(s) even actually exist.
+ if((targets) && (destination))
+ {
+ for(i = 0; i < argc; ++i)
+ {
+ // Check to see if the player is a valid target
+ if((stof(argv(i)) < 1) | (stof(argv(i)) > maxclients)) // player_id is out of range
+ {
+ print(strcat("Player ", argv(i), " doesn't exist", (((i + 1) < argc) ? ", skipping to next player.\n" : ".\n")));
+ continue;
+ }
+ client = edict_num(stof(argv(i)));
+ if not(client.flags & FL_CLIENT) // player entity is not a client
+ {
+ print(strcat("Player ", argv(i), " doesn't exist", (((i + 1) < argc) ? ", skipping to next player.\n" : ".\n")));
+ continue;
+ }
+
+ // Where are we putting this player?
+ if(destination == "spec" || destination == "spectator")
+ {
+ if(client.classname != "spectator" && client.classname != "observer")
+ {
+ self = client;
+ PutObserverInServer();
+ }
+ else
+ {
+ print("Player ", argv(i), " (", client.netname, ") is already spectating.\n");
+ }
+ return;
+ }
+ else
+ {
+ if(client.classname != "spectator" && client.classname != "observer")
+ {
+ if(teamplay)
+ {
+ // set up
+ float team_color;
+ float save = client.team_forced;
+ client.team_forced = 0;
+
+ // find the team to move the player to
+ team_color = ColourToNumber(destination);
+ if(team_color == client.team) // already on the destination team
+ {
+ // keep the forcing undone
+ print("Player ", argv(i), " (", client.netname, ") is already on the ", ColoredTeamName(client.team), ".\n");
+ return;
+ }
+ else if(team_color == 0) // auto team
+ {
+ team_color = NumberToTeamNumber(FindSmallestTeam(client, FALSE));
+ }
+ else
+ {
+ CheckAllowedTeams(client);
+ }
+ client.team_forced = save;
+
+ // Check to see if the destination team is even available
+ switch(team_color)
+ {
+ case COLOR_TEAM1:
+ if(c1 == -1) {
+ print("Sorry, can't move player to red team if it doesn't exist.\n");
+ return;
+ }
+ break;
+
+ case COLOR_TEAM2:
+ if(c2 == -1) {
+ print("Sorry, can't move player to blue team if it doesn't exist.\n");
+ return;
+ }
+ break;
+
+ case COLOR_TEAM3:
+ if(c3 == -1) {
+ print("Sorry, can't move player to yellow team if it doesn't exist.\n");
+ return;
+ }
+ break;
+
+ case COLOR_TEAM4:
+ if(c4 == -1) {
+ print("Sorry, can't move player to pink team if it doesn't exist.\n");
+ return;
+ }
+ break;
+
+ default:
+ print("Sorry, can't move player here if team ", destination, " doesn't exist.\n");
+ return;
+ }
+
+ // If so, lets continue and finally move the player
+ client.team_forced = 0;
+ MoveToTeam(client, team_color, 6, stof(notify));
+ print("Player ", argv(i), " (", client.netname, ") has been moved to the ", ColoredTeamName(team_color), ".\n");
+ return;
+ }
+ else
+ {
+ print("Can't change teams when currently not playing a team game.\n");
+ return;
+ }
+ }
+ else
+ {
+ print("Can't change teams if the player isn't in the game.\n"); // well technically we could, but should we allow that? :P
+ return;
+ }
+ }
+ }
+ print("No acceptable players given, aborting.\n");
+ return; // still correct parameters so return to avoid usage print
+ }
+
+ default:
+ print("Incorrect parameters for ^2moveplayer^7\n");
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd moveplayer clientnumbers destination [notify]\n");
+ print(" 'clientnumbers' is a list (separated by commas) of player entity ID's\n");
+ print(" 'destination' is what to send the player to, be it team or spectating\n");
+ print(" Full list of destinations here: \"spec, spectator, red, blue, yellow, pink, auto.\"\n");
+ print(" 'notify' is whether or not to send messages notifying of the move. Detail below.\n");
+ print(" 0 (00) automove centerprint, admin message; 1 (01) automove centerprint, no admin message\n");
+ print(" 2 (10) no centerprint, admin message; 3 (11) no centerprint, no admin message\n");
+ print("Examples: moveplayer 1,3,5 red 3\n");
+ print(" moveplayer 2 spec \n");
+ print("See also: ^2allspec^7\n");
+ return;
+ }
+}
+
+void GameCommand_nospectators(float request)
+{
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2nospectators^7: Automatically remove spectators from a match\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ blockSpectators = 1;
+ entity plr;
+ FOR_EACH_CLIENT(plr) //give every spectator <g_maxplayers_spectator_blocktime> seconds time to become a player
+ {
+ if(plr.classname == "spectator" || plr.classname == "observer")
+ {
+ plr.spectatortime = time;
+ sprint(plr, strcat("^7You have to become a player within the next ", ftos(autocvar_g_maxplayers_spectator_blocktime), " seconds, otherwise you will be kicked, because spectators aren't allowed at this time!\n"));
+ }
+ }
+ bprint(strcat("^7All spectators will be automatically kicked when not joining the game after ", ftos(autocvar_g_maxplayers_spectator_blocktime), " seconds!\n"));
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd nospectators\n");
+ print(" No arguments required.\n");
+ return;
+ }
+}
+
+void GameCommand_onslaught_updatelinks(float request) // UNTESTED // should this be here? Perhaps some mutatorhook call instead....
+{
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2onslaught_updatelinks^7: Refresh link status for onslaught\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ onslaught_updatelinks();
+ print("ONS links updated\n");
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd onslaught_updatelinks\n");
+ print(" No arguments required.\n");
+ return;
+ }
+}
+
+void GameCommand_playerdemo(float request, float argc) // UNTESTED // TODO: change the if statements for sub arguments to switches
+{
+ entity client;
+ float i, n, entno;
+ string s;
- // Add ifdef to stuffto so that is can only be used when the game code is compiled for it
- //(this way it's more obscure and harder to abuse on normal servers)
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2playerdemo^7: Control the ability to save demos of players\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ if(argv(1) == "read")
+ {
+ // TODO: Create a general command for looking this up, save a lot of space everywhere in this file
+ entno = stof(argv(2));
+ if((entno < 1) | (entno > maxclients)) {
+ print("Player ", argv(2), " doesn't exist\n");
+ return;
+ }
+ client = edict_num(entno);
+ if(clienttype(client) != CLIENTTYPE_BOT) {
+ print("Player ", client.netname, " is not a bot\n");
+ return;
+ }
+ self = client;
+ playerdemo_open_read(argv(3));
+ return;
+ }
+ else if(argv(1) == "write")
+ {
+ entno = stof(argv(2));
+ if((entno < 1) | (entno > maxclients)) {
+ print("Player ", argv(2), " doesn't exist\n");
+ return;
+ }
+ client = edict_num(entno);
+ self = client;
+ playerdemo_open_write(argv(3));
+ return;
+ }
+ else if(argv(1) == "auto_read_and_write")
+ {
+ s = argv(2);
+ n = stof(argv(3));
+ cvar_set("bot_number", ftos(n));
+ localcmd("wait; wait; wait\n");
+ for(i = 0; i < n; ++i)
+ localcmd("sv_cmd playerdemo read ", ftos(i+2), " ", s, ftos(i+1), "\n");
+ localcmd("sv_cmd playerdemo write 1 ", ftos(n+1), "\n");
+ return;
+ }
+ else if(argv(1) == "auto_read")
+ {
+ s = argv(2);
+ n = stof(argv(3));
+ cvar_set("bot_number", ftos(n));
+ localcmd("wait; wait; wait\n");
+ for(i = 0; i < n; ++i)
+ localcmd("sv_cmd playerdemo read ", ftos(i+2), " ", s, ftos(i+1), "\n");
+ return;
+ }
+ return;
+
+ default:
+ print("Incorrect parameters for ^2radarmap^7\n");
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd \n");
+ print(" FIXME: Arguments currently unknown\n");
+ return;
+ }
+}
+
+void GameCommand_printstats(float request)
+{
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2printstats^7: foobar\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ DumpStats(FALSE);
+ print("stats dumped.\n");
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd printstats\n");
+ print(" No arguments required.\n");
+ return;
+ }
+}
+
+void GameCommand_radarmap(float request, float argc)
+{
+ float i;
+
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2radarmap^7: Generate a radar image of the map\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ if(!radarmapper)
+ {
+ radarmapper = spawn();
+ radarmapper.classname = "radarmapper";
+ radarmapper.think = RadarMap_Think;
+ radarmapper.nextthink = time;
+ radarmapper.count = 8; // default to the --trace method, as it is faster now
+ radarmapper.ltime = 1;
+ radarmapper.size = '512 512 1';
+
+ for(i = 1; i < argc; ++i)
+ {
+ switch(argv(i))
+ {
+ case "--force": { radarmapper.count |= 1; break; }
+ case "--loop": { radarmapper.count |= 2; break; }
+ case "--quit": { radarmapper.count |= 4; break; }
+ case "--block": { radarmapper.count &~= 24; break; }
+ case "--trace": { radarmapper.count &~= 24; radarmapper.count |= 8; break; }
+ case "--sample": { radarmapper.count &~= 24; radarmapper.count |= 16; break; }
+ case "--lineblock": { radarmapper.count |= 24; break; }
+ case "--flags": { ++i; radarmapper.count = stof(argv(i)); break; } // for the recursive call
+ case "--sharpen": { ++i; radarmapper.ltime = stof(argv(i)); break; } // for the recursive call
+ case "--res": // minor alias
+ case "--resolution": { ++i; radarmapper.size_x = stof(argv(i)); ++i; radarmapper.size_y = stof(argv(i)); break; }
+ case "--qual": // minor alias
+ case "--quality": { ++i; radarmapper.size_z = stof(argv(i)); break; }
+
+ default:
+ i = argc;
+ remove(radarmapper);
+ radarmapper = world;
+ break;
+ }
+ }
+
+ if(radarmapper) // after doing the arguments, see if we successfully went forward.
+ {
+ print("Radarmap entity spawned.\n");
+ return; // if so, don't print usage.
+ }
+ }
+
+ default:
+ print("Incorrect parameters for ^2radarmap^7\n");
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd radarmap [--force] [--loop] [--quit] [--block | --trace | --sample | --lineblock] [--sharpen N] [--res W H] [--qual Q]\n");
+ print(" The quality factor Q is roughly proportional to the time taken.\n");
+ print(" trace supports no quality factor; its result should look like --block with infinite quality factor.\n");
+ return;
+ }
+}
+
+void GameCommand_rankings(float request) // this is OLD.... jeez.
+{
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2rankings^7: Print information about rankings\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ strunzone(rankings_reply);
+ rankings_reply = strzone(getrankings());
+ print(rankings_reply);
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd rankings\n");
+ print(" No arguments required.\n");
+ return;
+ }
+}
+
+void GameCommand_records(float request)
+{
+ float i;
+
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2records^7: List top 10 records for the current map\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ for (i = 0; i < 10; ++i)
+ print(records_reply[i]);
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd records\n");
+ print(" No arguments required.\n");
+ return;
+ }
+}
+
+void GameCommand_reducematchtime(float request)
+{
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2reducematchtime^7: Decrease the timelimit value incrementally\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ changematchtime(autocvar_timelimit_decrement*-60, autocvar_timelimit_min*60, autocvar_timelimit_max*60);
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd reducematchtime\n");
+ print(" No arguments required.\n");
+ print("See also: ^2extendmatchtime^7\n");
+ return;
+ }
+}
+
+void GameCommand_stuffto(float request, float argc)
+{
+ // This... is a fairly dangerous and powerful command... - It allows any arguments to be sent to a client via rcon.
+ // Because of this, it is disabled by default and must be enabled by the server owner when doing compilation. That way,
+ // we can be certain they understand the risks of it... So to enable, compile server with -DSTUFFTO_ENABLED argument.
+
+ entity client;
+ float entno;
+
+ #ifdef STUFFTO_ENABLED
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2stuffto^7: Send a command to be executed on a client\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ if(argc == 3)
+ {
+ entno = stof(argv(1));
+ client = world;
+ if(entno <= maxclients)
+ client = edict_num(entno);
+ if(client.flags & FL_CLIENT)
+ {
+ stuffcmd(client, strcat("\n", argv(2), "\n"));
+ print(strcat("Command: \"", argv(2), "\" sent to ", client.netname, " (", argv(1) ,").\n"));
+ }
+ else
+ print(strcat("Client (", argv(1) ,") not found.\n"));
+
+ return;
+ }
+
+ default:
+ print("Incorrect parameters for ^2stuffto^7\n");
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd stuffto clientnumber command\n");
+ print(" FIXME: Arguments currently unknown\n");
+ return;
+ }
+ #else // give the response for missing command to fake them out ;3
+ if(request == GC_REQUEST_COMMAND)
+ {
+ print("Invalid command. For a list of supported commands, try sv_cmd help.\n");
+ return;
+ }
+ #endif
+}
+
+void GameCommand_teamstatus(float request)
+{
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2teamstatus^7: Show information about player and team scores\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ Score_NicePrint(world);
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd teamstatus\n");
+ print(" No arguments required.\n");
+ return;
+ }
+}
+
+void GameCommand_time(float request)
+{
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2time^7: Print different formats/readouts of time\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ print("time = ", ftos(time), "\n");
+ print("frame start = ", ftos(gettime(GETTIME_FRAMESTART)), "\n");
+ print("realtime = ", ftos(gettime(GETTIME_REALTIME)), "\n");
+ print("hires = ", ftos(gettime(GETTIME_HIRES)), "\n");
+ print("uptime = ", ftos(gettime(GETTIME_UPTIME)), "\n");
+ print("localtime = ", strftime(TRUE, "%a %b %e %H:%M:%S %Z %Y"), "\n"); // FIXME: Why is strftime broken? is engine problem, I think.
+ print("gmtime = ", strftime(FALSE, "%a %b %e %H:%M:%S %Z %Y"), "\n");
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd time\n");
+ print(" No arguments required.\n");
+ return;
+ }
+}
+
+void GameCommand_trace(float request, float argc)
+{
+ entity e;
+ vector org, delta, start, end, p, q, q0, pos, vv, dv;
+ float i, f, safe, unsafe, dq, dqf;
+
+ // TODO: Clean up all of these variables and merge the code below to use only a few
+
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2trace^7: Various debugging tools with tracing\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ switch(argv(1))
+ {
+ case "debug":
+ print("TEST CASE. If this returns the runaway loop counter error, possibly everything is oaky.\n");
+ for(;;)
+ {
+ org = world.mins;
+ delta = world.maxs - world.mins;
+
+ start_x = org_x + random() * delta_x;
+ start_y = org_y + random() * delta_y;
+ start_z = org_z + random() * delta_z;
+
+ end_x = org_x + random() * delta_x;
+ end_y = org_y + random() * delta_y;
+ end_z = org_z + random() * delta_z;
+
+ start = stov(vtos(start));
+ end = stov(vtos(end));
+
+ tracebox(start, PL_MIN, PL_MAX, end, MOVE_NOMONSTERS, world);
+ if(!trace_startsolid)
+ {
+ p = trace_endpos;
+ tracebox(p, PL_MIN, PL_MAX, p, MOVE_NOMONSTERS, world);
+ if(trace_startsolid || trace_fraction == 1)
+ {
+ rint(42); // do an engine breakpoint on VM_rint so you can get the trace that errnoeously returns startsolid
+ tracebox(start, PL_MIN, PL_MAX, end, MOVE_NOMONSTERS, world);
+ tracebox(p, PL_MIN, PL_MAX, q, MOVE_NOMONSTERS, world);
+
+ if(trace_startsolid)
+ {
+ // how much do we need to back off?
+ safe = 1;
+ unsafe = 0;
+ for(;;)
+ {
+ pos = p * (1 - (safe + unsafe) * 0.5) + start * ((safe + unsafe) * 0.5);
+ tracebox(pos, PL_MIN, PL_MAX, pos, MOVE_NOMONSTERS, world);
+ if(trace_startsolid)
+ {
+ if((safe + unsafe) * 0.5 == unsafe)
+ break;
+ unsafe = (safe + unsafe) * 0.5;
+ }
+ else
+ {
+ if((safe + unsafe) * 0.5 == safe)
+ break;
+ safe = (safe + unsafe) * 0.5;
+ }
+ }
+
+ print("safe distance to back off: ", ftos(safe * vlen(p - start)), "qu\n");
+ print("unsafe distance to back off: ", ftos(unsafe * vlen(p - start)), "qu\n");
+
+ tracebox(p, PL_MIN + '0.1 0.1 0.1', PL_MAX - '0.1 0.1 0.1', p, MOVE_NOMONSTERS, world);
+ if(trace_startsolid)
+ print("trace_endpos much in solid when tracing from ", vtos(start), " to ", vtos(end), " endpos ", vtos(p), "\n");
+ else
+ print("trace_endpos just in solid when tracing from ", vtos(start), " to ", vtos(end), " endpos ", vtos(p), "\n");
+ break;
+ }
+
+ q0 = p;
+ dq = 0;
+ dqf = 1;
+ for(;;)
+ {
+ q = p + normalize(end - p) * (dq + dqf);
+ if(q == q0)
+ break;
+ tracebox(p, PL_MIN, PL_MAX, q, MOVE_NOMONSTERS, world);
+ if(trace_startsolid)
+ error("THIS ONE cannot happen");
+ if(trace_fraction > 0)
+ dq += dqf * trace_fraction;
+ dqf *= 0.5;
+ q0 = q;
+ }
+ if(dq > 0)
+ {
+ print("trace_endpos still before solid when tracing from ", vtos(start), " to ", vtos(end), " endpos ", vtos(p), "\n");
+ print("could go ", ftos(dq), " units further to ", vtos(q), "\n");
+ break;
+ }
+ }
+ }
+ }
+ return;
+
+ case "debug2":
+ e = nextent(world);
+ tracebox(e.origin + '0 0 32', e.mins, e.maxs, e.origin + '0 0 -1024', MOVE_NORMAL, e);
+ vv = trace_endpos;
+ if(trace_fraction == 1)
+ {
+ print("not above ground, aborting\n");
+ return;
+ }
+ f = 0;
+ for(i = 0; i < 100000; ++i)
+ {
+ dv = randomvec();
+ if(dv_z > 0)
+ dv = -1 * dv;
+ tracebox(vv, e.mins, e.maxs, vv + dv, MOVE_NORMAL, e);
+ if(trace_startsolid)
+ print("bug 1\n");
+ if(trace_fraction == 1)
+ if(dv_z < f)
+ {
+ print("bug 2: ", ftos(dv_x), " ", ftos(dv_y), " ", ftos(dv_z));
+ print(" (", ftos(asin(dv_z / vlen(dv)) * 180 / M_PI), " degrees)\n");
+ f = dv_z;
+ }
+ }
+ print("highest possible dist: ", ftos(f), "\n");
+ return;
+
+ case "walk":
+ if(argc == 3)
+ {
+ e = nextent(world);
+ if(tracewalk(e, stov(argv(1)), e.mins, e.maxs, stov(argv(2)), MOVE_NORMAL))
+ print("can walk\n");
+ else
+ print("cannot walk\n");
+ return;
+ }
+
+ case "showline":
+ if(argc == 3)
+ {
+ vv = stov(argv(1));
+ dv = stov(argv(2));
+ traceline(vv, dv, MOVE_NORMAL, world);
+ trailparticles(world, particleeffectnum("TR_NEXUIZPLASMA"), vv, trace_endpos);
+ trailparticles(world, particleeffectnum("TR_CRYLINKPLASMA"), trace_endpos, dv);
+ return;
+ }
+
+ // no default case, just go straight to "invalid arguments"
+ }
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd trace command [arguments]\n");
+ print(" FIXME: Arguments currently unknown\n");
+ return;
+ }
+}
+
+void GameCommand_unlockteams(float request)
+{
+ switch(request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2unlockteams^7: Enable the ability for players to switch or enter teams\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ if(teamplay)
+ {
+ lockteams = 0;
+ bprint("^1The teams are now unlocked.\n");
+ }
+ else
+ bprint("That command can only be used in a team-based gamemode.\n");
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd unlockteams\n");
+ print(" No arguments required.\n");
+ print("See also: ^2lockteams^7\n");
+ return;
+ }
+}
+
+void GameCommand_warp(float request, float argc)
+{
+ switch (request)
+ {
+ case GC_REQUEST_HELP:
+ print(" ^2warp^7: Choose different level in campaign\n");
+ return;
+
+ case GC_REQUEST_COMMAND:
+ if(autocvar_g_campaign)
+ {
+
+ if(argc >= 2)
+ {
+ CampaignLevelWarp(stof(argv(1)));
+ print("Successfully warped to campaign level ", stof(argv(1)), ".\n");
+ }
+ else
+ {
+ CampaignLevelWarp(-1);
+ print("Successfully warped to next campaign level.\n");
+ }
+ }
+ else
+ print("Not in campaign, can't level warp\n");
+ return;
+
+ default:
+ case GC_REQUEST_USAGE:
+ print("\nUsage:^3 sv_cmd level\n");
+ print(" 'level' is the level to change campaign mode to.\n");
+ return;
+ }
+}
+
+
+// =========================================
+// Main Function Called By Engine (sv_cmd)
+// =========================================
+// If this function exists, game code handles gamecommand instead of the engine code.
+
+void GameCommand(string command)
+{
+ // ===== TODO list =====
+ // find all FIXME's and TODO'S and UNTESTED'S and finish them :P
float search_request_type;
float argc = tokenize_console(command);
- if(argv(0) == "help")
+ if(strtolower(argv(0)) == "help")
{
if(argc == 1)
{
- print("\nUsage: sv_cmd COMMAND..., where possible commands are:\n");
- GameCommand_adminmsg(GC_REQUEST_HELP, "");
+ print("\nUsage:^3 sv_cmd COMMAND...^7, where possible commands are:\n");
+ GameCommand_adminmsg(GC_REQUEST_HELP, 0);
GameCommand_allready(GC_REQUEST_HELP);
- GameCommand_allspec(GC_REQUEST_HELP);
- GameCommand_anticheat(GC_REQUEST_HELP, "");
+ GameCommand_allspec(GC_REQUEST_HELP, 0);
+ GameCommand_anticheat(GC_REQUEST_HELP, 0);
GameCommand_bbox(GC_REQUEST_HELP);
- GameCommand_bot_cmd(GC_REQUEST_HELP, "");
- GameCommand_cointoss(GC_REQUEST_HELP);
+ GameCommand_bot_cmd(GC_REQUEST_HELP, 0);
+ GameCommand_cointoss(GC_REQUEST_HELP, 0);
GameCommand_cvar_changes(GC_REQUEST_HELP);
GameCommand_cvar_purechanges(GC_REQUEST_HELP);
- GameCommand_database(GC_REQUEST_HELP, "");
- GameCommand_defer_clear(GC_REQUEST_HELP, "");
+ GameCommand_database(GC_REQUEST_HELP, 0);
+ GameCommand_defer_clear(GC_REQUEST_HELP, 0);
GameCommand_defer_clear_all(GC_REQUEST_HELP);
- GameCommand_delrec(GC_REQUEST_HELP, "");
+ GameCommand_delrec(GC_REQUEST_HELP, 0);
GameCommand_effectindexdump(GC_REQUEST_HELP);
GameCommand_extendmatchtime(GC_REQUEST_HELP);
- GameCommand_find(GC_REQUEST_HELP, "");
- GameCommand_gametype(GC_REQUEST_HELP, "");
- GameCommand_gettaginfo(GC_REQUEST_HELP, "");
- GameCommand_gotomap(GC_REQUEST_HELP, "");
+ GameCommand_find(GC_REQUEST_HELP, 0);
+ GameCommand_gametype(GC_REQUEST_HELP, 0);
+ GameCommand_gettaginfo(GC_REQUEST_HELP, 0);
+ GameCommand_gotomap(GC_REQUEST_HELP, 0);
GameCommand_ladder(GC_REQUEST_HELP);
GameCommand_lockteams(GC_REQUEST_HELP);
- print(" teamstatus\n");
- print(" printstats\n");
- print(" make_mapinfo\n");
- print(" radarmap [--force] [--quit | --loop] [sharpness]\n");
- print(" reducematchtime\n");
+ GameCommand_make_mapinfo(GC_REQUEST_HELP);
+ GameCommand_modelbug(GC_REQUEST_HELP);
+ GameCommand_moveplayer(GC_REQUEST_HELP, 0);
+ GameCommand_nospectators(GC_REQUEST_HELP);
+ GameCommand_onslaught_updatelinks(GC_REQUEST_HELP);
+ GameCommand_playerdemo(GC_REQUEST_HELP, 0);
+ GameCommand_printstats(GC_REQUEST_HELP);
+ GameCommand_radarmap(GC_REQUEST_HELP, 0);
+ GameCommand_rankings(GC_REQUEST_HELP);
+ GameCommand_records(GC_REQUEST_HELP);
+ GameCommand_reducematchtime(GC_REQUEST_HELP);
+ GameCommand_stuffto(GC_REQUEST_HELP, 0);
+ GameCommand_teamstatus(GC_REQUEST_HELP);
+ GameCommand_time(GC_REQUEST_HELP);
+ GameCommand_trace(GC_REQUEST_HELP, 0);
+ GameCommand_unlockteams(GC_REQUEST_HELP);
+ GameCommand_warp(GC_REQUEST_HELP, 0);
GameCommand_Vote("help", world);
GameCommand_Ban("help");
GameCommand_Generic("help");
else
search_request_type = GC_REQUEST_COMMAND; // continue as usual and scan for normal commands
- switch( ((argv(0) == "help") ? argv(1) : argv(0)) ) // if first argument is help, then search for the second argument. Else, search for first.
+ switch(strtolower((search_request_type == GC_REQUEST_USAGE) ? argv(1) : argv(0))) // if first argument is help, then search for the second argument. Else, search for first.
{
- case "adminmsg": GameCommand_adminmsg(search_request_type, command); break;
+ // Do not hard code aliases for these, instead create them in defaultXonotic.cfg
+ // also: keep in alphabetical order, please ;)
+
+ case "adminmsg": GameCommand_adminmsg(search_request_type, argc); break;
case "allready": GameCommand_allready(search_request_type); break;
- case "allspec": GameCommand_allspec(search_request_type); break;
- case "anticheat": GameCommand_anticheat(search_request_type, command); break;
+ case "allspec": GameCommand_allspec(search_request_type, argc); break;
+ case "anticheat": GameCommand_anticheat(search_request_type, argc); break;
case "bbox": GameCommand_bbox(search_request_type); break;
- case "bot_cmd": GameCommand_bot_cmd(search_request_type, command); break;
- case "cointoss": GameCommand_cointoss(search_request_type); break;
+ case "bot_cmd": GameCommand_bot_cmd(search_request_type, argc); break;
+ case "cointoss": GameCommand_cointoss(search_request_type, argc); break;
case "cvar_changes": GameCommand_cvar_changes(search_request_type); break;
case "cvar_purechanges": GameCommand_cvar_purechanges(search_request_type); break;
- case "database": GameCommand_database(search_request_type, command); break;
- case "defer_clear": GameCommand_defer_clear(search_request_type, command); break;
+ case "database": GameCommand_database(search_request_type, argc); break;
+ case "defer_clear": GameCommand_defer_clear(search_request_type, argc); break;
case "defer_clear_all": GameCommand_defer_clear_all(search_request_type); break;
- case "delrec": GameCommand_delrec(search_request_type, command); break;
+ case "delrec": GameCommand_delrec(search_request_type, argc); break;
case "effectindexdump": GameCommand_effectindexdump(search_request_type); break;
case "extendmatchtime": GameCommand_extendmatchtime(search_request_type); break;
- case "find": GameCommand_find(search_request_type, command); break;
- case "gametype": GameCommand_gametype(search_request_type, command); break;
- case "gettaginfo": GameCommand_gettaginfo(search_request_type, command); break;
- case "gotomap": GameCommand_gotomap(search_request_type, command); break;
+ case "find": GameCommand_find(search_request_type, argc); break;
+ case "gametype": GameCommand_gametype(search_request_type, argc); break;
+ case "gettaginfo": GameCommand_gettaginfo(search_request_type, argc); break;
+ case "gotomap": GameCommand_gotomap(search_request_type, argc); break;
case "ladder": GameCommand_ladder(search_request_type); break;
case "lockteams": GameCommand_lockteams(search_request_type); break;
+ case "make_mapinfo": GameCommand_make_mapinfo(search_request_type); break;
+ case "modelbug": GameCommand_modelbug(search_request_type); break;
+ case "moveplayer": GameCommand_moveplayer(search_request_type, argc); break;
+ case "nospectators": GameCommand_nospectators(search_request_type); break;
+ case "onslaught_updatelinks": GameCommand_onslaught_updatelinks(search_request_type); break;
+ case "playerdemo": GameCommand_playerdemo(search_request_type, argc); break;
+ case "printstats": GameCommand_printstats(search_request_type); break;
+ case "radarmap": GameCommand_radarmap(search_request_type, argc); break;
+ case "rankings": GameCommand_rankings(search_request_type); break;
+ case "records": GameCommand_records(search_request_type); break;
+ case "reducematchtime": GameCommand_reducematchtime(search_request_type); break;
+ case "stuffto": GameCommand_stuffto(search_request_type, argc); break;
+ case "teamstatus": GameCommand_teamstatus(search_request_type); break;
+ case "time": GameCommand_time(search_request_type); break;
+ case "trace": GameCommand_trace(search_request_type, argc); break;
+ case "unlockteams": GameCommand_unlockteams(search_request_type); break;
+ case "warp": GameCommand_warp(search_request_type, argc); break;
default:
print("Invalid command. For a list of supported commands, try sv_cmd help.\n");
}
-}
-
+}
\ No newline at end of file
projects / xonotic / xonotic-data.pk3dir.git / blobdiff