#include "quakedef.h"

int current_skill;
bool noclip_anglehack;

extern void M_Menu_Quit_f(cmd_t *c);

void
Host_Quit_f(cmd_t *c)
{
	USED(c);
	if(key_dest != key_console && cls.state != ca_dedicated) {
		M_Menu_Quit_f(c);
		return;
	}
	CL_Disconnect();
	Host_ShutdownServer(false);

	game_shutdown();
}

static void
Host_Status_f(cmd_t *c)
{
	client_t *client;
	int seconds, minutes, hours, j;
	void (*print)(const char *fmt, ...) format_printf(1, 2);

	USED(c);
	if(cmd_source == src_command) {
		if(!sv.active) {
			Cmd_ForwardToServer(nil);
			return;
		}
		print = Con_Printf;
	} else
		print = SV_ClientPrintf;

	print("host:	%s\n", Cvar_VariableString("hostname"));
	print("version: %4.2f\n", VERSION);
	print("map:	 %s\n", sv.name);
	print("players: %d active (%d max)\n\n", net_activeconnections, svs.maxclients);
	for(j = 0, client = svs.clients; j < svs.maxclients; j++, client++) {
		if(!client->active)
			continue;
		seconds = (int)(net_time - client->netconnection->connecttime);
		minutes = seconds / 60;
		if(minutes) {
			seconds -= minutes * 60;
			hours = minutes / 60;
			if(hours)
				minutes -= hours * 60;
		} else
			hours = 0;
		print(
			"#%-2ud %-16.16s  %3d  %2d:%02d:%02d\n",
			j + 1,
			client->name,
			(int)client->edict->v.frags,
			hours,
			minutes,
			seconds
		);
		print("   %s\n", client->netconnection->address);
	}
}

static void
Host_God_f(cmd_t *c)
{
	USED(c);
	if(cmd_source == src_command) {
		Cmd_ForwardToServer(nil);
		return;
	}

	if(sv.pr->global_struct->deathmatch)
		return;

	sv_player->v.flags = (int)sv_player->v.flags ^ FL_GODMODE;
	if(!((int)sv_player->v.flags & FL_GODMODE))
		SV_ClientPrintf("godmode OFF\n");
	else
		SV_ClientPrintf("godmode ON\n");
}

static void
Host_Notarget_f(cmd_t *c)
{
	USED(c);
	if(cmd_source == src_command) {
		Cmd_ForwardToServer(nil);
		return;
	}

	if(sv.pr->global_struct->deathmatch)
		return;

	sv_player->v.flags = (int)sv_player->v.flags ^ FL_NOTARGET;
	if(!((int)sv_player->v.flags & FL_NOTARGET))
		SV_ClientPrintf("notarget OFF\n");
	else
		SV_ClientPrintf("notarget ON\n");
}

static void
Host_Noclip_f(cmd_t *c)
{
	USED(c);
	if(cmd_source == src_command) {
		Cmd_ForwardToServer(nil);
		return;
	}

	if(sv.pr->global_struct->deathmatch)
		return;

	if(sv_player->v.movetype != MOVETYPE_NOCLIP) {
		noclip_anglehack = true;
		sv_player->v.movetype = MOVETYPE_NOCLIP;
		SV_ClientPrintf("noclip ON\n");
	} else {
		noclip_anglehack = false;
		sv_player->v.movetype = MOVETYPE_WALK;
		SV_ClientPrintf("noclip OFF\n");
	}
}

static void
Host_Fly_f(cmd_t *c)
{
	USED(c);
	if(cmd_source == src_command) {
		Cmd_ForwardToServer(nil);
		return;
	}

	if(sv.pr->global_struct->deathmatch)
		return;

	if(sv_player->v.movetype != MOVETYPE_FLY) {
		sv_player->v.movetype = MOVETYPE_FLY;
		SV_ClientPrintf("flymode ON\n");
	} else {
		sv_player->v.movetype = MOVETYPE_WALK;
		SV_ClientPrintf("flymode OFF\n");
	}
}

static void
Host_Ping_f(cmd_t *c)
{
	int i, j;
	float total;
	client_t *client;

	USED(c);
	if(cmd_source == src_command) {
		Cmd_ForwardToServer(nil);
		return;
	}

	SV_ClientPrintf("Client ping times:\n");
	for(i = 0, client = svs.clients; i < svs.maxclients; i++, client++) {
		if(!client->active)
			continue;
		total = 0;
		for(j = 0; j < NUM_PING_TIMES; j++)
			total += client->ping_times[j];
		total /= NUM_PING_TIMES;
		SV_ClientPrintf("%4d %s\n", (int)(total * 1000), client->name);
	}
}

/* handle a "map <servername>" command from the console.  Active clients are kicked off. */
static void
Host_Map_f(cmd_t *c)
{
	int i;
	char name[Npath];

	if(Cmd_Argc() < 2) {
		if(cls.state != ca_disconnected)
			Con_Printf("%s\n", cls.mapstring);
		return;
	}
	USED(c);
	if(cmd_source != src_command)
		return;

	cls.demonum = -1; // stop demo loop in case this fails

	CL_Disconnect();
	Host_ShutdownServer(false);

	key_dest = key_game; // remove console or menu
	SCR_BeginLoadingPlaque();

	cls.mapstring[0] = 0;
	for(i = 0; i < Cmd_Argc(); i++) {
		strcat(cls.mapstring, Cmd_Argv(i));
		strcat(cls.mapstring, " ");
	}
	strcat(cls.mapstring, "\n");

	svs.serverflags = 0; // haven't completed an episode yet
	strcpy(name, Cmd_Argv(1));
	SV_SpawnServer(name);
	if(!sv.active)
		return;

	if(cls.state != ca_dedicated) {
		strcpy(cls.spawnparms, "");

		for(i = 2; i < Cmd_Argc(); i++) {
			strcat(cls.spawnparms, Cmd_Argv(i));
			strcat(cls.spawnparms, " ");
		}

		Cmd_ExecuteString("connect local", src_command);
	}
}

/* Goes to a new map, taking all clients along */
static void
Host_Changelevel_f(cmd_t *c)
{
	char level[Npath];

	USED(c);
	if(Cmd_Argc() != 2) {
		Con_Printf("changelevel <levelname> : continue game on a new level\n");
		return;
	}
	if(!sv.active || cls.demoplayback) {
		Con_Printf("Only the server may changelevel\n");
		return;
	}
	SV_SaveSpawnparms();
	strcpy(level, Cmd_Argv(1));
	SV_SpawnServer(level);
}

/* Restarts the current server for a dead player */
static void
Host_Restart_f(cmd_t *c)
{
	char mapname[Npath];

	USED(c);
	if(cls.demoplayback || !sv.active)
		return;
	if(cmd_source != src_command)
		return;
	strcpy(mapname, sv.name); // must copy out, because it gets cleared in sv_spawnserver
	SV_SpawnServer(mapname);
}

/* wait for signon messages; sent before server level change */
static void
reconnect(cmd_t *c)
{
	USED(c);
	SCR_BeginLoadingPlaque();
	cls.signon = 0;
}

/* User command to connect to server */
static void
Host_Connect_f(cmd_t *c)
{
	char name[Npath];

	USED(c);
	cls.demonum = -1; // stop demo loop in case this fails
	if(cls.demoplayback) {
		abortdemo();
		CL_Disconnect();
	}
	strcpy(name, Cmd_Argv(1));
	CL_EstablishConnection(name);
	reconnect(c);
}

static void
Host_Name_f(cmd_t *c)
{
	char newName[16];

	USED(c);
	if(Cmd_Argc() == 1) {
		Con_Printf("\"name\" is \"%s\"\n", cl_name.string);
		return;
	}
	if(Cmd_Argc() == 2)
		strncpy(newName, Cmd_Argv(1), sizeof(newName));
	else
		strncpy(newName, Cmd_Args(), sizeof(newName));
	newName[sizeof(newName) - 1] = 0;

	if(cmd_source == src_command) {
		if(strcmp(cl_name.string, newName) == 0)
			return;
		setcvar("_cl_name", newName);
		if(cls.state == ca_connected)
			Cmd_ForwardToServer(nil);
		return;
	}

	if(host_client->name[0] && strcmp(host_client->name, "unconnected") != 0) {
		if(strcmp(host_client->name, newName) != 0)
			Con_Printf("%s renamed to %s\n", host_client->name, newName);
	}
	strcpy(host_client->name, newName);
	host_client->edict->v.netname = PR_SetStr(sv.pr, host_client->name);

	// send notification to all clients

	MSG_WriteByte(&sv.reliable_datagram, svc_updatename);
	MSG_WriteByte(&sv.reliable_datagram, host_client - svs.clients);
	MSG_WriteString(&sv.reliable_datagram, host_client->name);
}

static void
Host_Version_f(cmd_t *c)
{
	USED(c);
	Con_Printf("Version %4.2f\n", VERSION);
	Con_Printf("Exe: <REDACTED>\n");
}

static void
Host_Say(bool teamonly)
{
	bool fromServer = false, quoted = false;
	client_t *client, *save;
	const char *p;
	char *text;
	int j, n;

	if(cmd_source == src_command) {
		if(cls.state == ca_dedicated) {
			fromServer = true;
			teamonly = false;
		} else {
			Cmd_ForwardToServer(nil);
			return;
		}
	}

	if(Cmd_Argc() < 2)
		return;

	save = host_client;

	p = Cmd_Args();
	quoted = *p == '"' && p[strlen(p) - 1] == '"';
	if(quoted)
		p++;
	// turn on color set 1
	if(fromServer)
		text = va("%c<%s> %s", 1, hostname.string, p);
	else
		text = va("%c%s: %s", 1, save->name, p);
	n = strlen(text);
	if(quoted)
		n--;
	text[n++] = '\n';
	text[n++] = 0;

	for(j = 0, client = svs.clients; j < svs.maxclients; j++, client++) {
		if(!client || !client->active || !client->spawned)
			continue;
		if(teamplay.value && teamonly && client->edict->v.team != save->edict->v.team)
			continue;
		host_client = client;
		SV_ClientPrintf("%s", text);
	}
	host_client = save;
	Con_DPrintf("%s", text + 1);
}

static void
Host_Say_f(cmd_t *c)
{
	USED(c);
	Host_Say(false);
}

static void
Host_Say_Team_f(cmd_t *c)
{
	USED(c);
	Host_Say(true);
}

static void
Host_Tell_f(cmd_t *c)
{
	client_t *client, *save;
	bool quoted = false;
	const char *p;
	char *text;
	int j, n;

	USED(c);
	if(cmd_source == src_command) {
		Cmd_ForwardToServer(nil);
		return;
	}

	if(Cmd_Argc() < 3)
		return;

	p = Cmd_Args();
	quoted = *p == '"' && p[strlen(p) - 1] == '"';
	if(quoted)
		p++;
	text = va("%s: %s", host_client->name, p);
	n = strlen(text);
	if(quoted)
		n--;
	text[n++] = '\n';
	text[n++] = 0;

	save = host_client;
	for(j = 0, client = svs.clients; j < svs.maxclients; j++, client++) {
		if(!client->active || !client->spawned)
			continue;
		if(cistrcmp(client->name, Cmd_Argv(1)) != 0)
			continue;
		host_client = client;
		SV_ClientPrintf("%s", text);
		break;
	}
	host_client = save;
}

static void
Host_Color_f(cmd_t *c)
{
	int top, bottom, playercolor;

	USED(c);
	if(Cmd_Argc() == 1) {
		Con_Printf(
			"\"color\" is \"%d %d\"\n", ((int)cl_color.value) >> 4, ((int)cl_color.value) & 0x0f
		);
		Con_Printf("color <0-13> [0-13]\n");
		return;
	}

	if(Cmd_Argc() == 2)
		top = bottom = atoi(Cmd_Argv(1));
	else {
		top = atoi(Cmd_Argv(1));
		bottom = atoi(Cmd_Argv(2));
	}

	top &= 15;
	if(top > 13)
		top = 13;
	bottom &= 15;
	if(bottom > 13)
		bottom = 13;

	playercolor = top * 16 + bottom;

	if(cmd_source == src_command) {
		setcvarv("_cl_color", playercolor);
		if(cls.state == ca_connected)
			Cmd_ForwardToServer(nil);
		return;
	}

	host_client->colors = playercolor;
	host_client->edict->v.team = bottom + 1;

	// send notification to all clients
	MSG_WriteByte(&sv.reliable_datagram, svc_updatecolors);
	MSG_WriteByte(&sv.reliable_datagram, host_client - svs.clients);
	MSG_WriteByte(&sv.reliable_datagram, host_client->colors);
}

static void
Host_Kill_f(cmd_t *c)
{
	USED(c);
	if(cmd_source == src_command) {
		Cmd_ForwardToServer(nil);
		return;
	}

	if(sv_player->v.health <= 0) {
		SV_ClientPrintf("Can't suicide -- already dead!\n");
		return;
	}

	sv.pr->global_struct->time = sv.time;
	sv.pr->global_struct->self = EDICT_TO_PROG(sv.pr, sv_player);
	PR_ExecuteProgram(sv.pr, sv.pr->global_struct->ClientKill);
}

static void
Host_Pause_f(cmd_t *c)
{
	USED(c);
	if(cmd_source == src_command) {
		Cmd_ForwardToServer(nil);
		return;
	}
	if(!pausable.value)
		SV_ClientPrintf("Pause not allowed.\n");
	else {
		sv.paused ^= 1;

		if(sv.paused)
			SV_BroadcastPrintf("%s paused the game\n", PR_Str(sv.pr, sv_player->v.netname));
		else
			SV_BroadcastPrintf("%s unpaused the game\n", PR_Str(sv.pr, sv_player->v.netname));

		// send notification to all clients
		MSG_WriteByte(&sv.reliable_datagram, svc_setpause);
		MSG_WriteByte(&sv.reliable_datagram, sv.paused);
	}
}

static void
Host_PreSpawn_f(cmd_t *c)
{
	USED(c);
	if(cmd_source == src_command) {
		Con_Printf("prespawn is not valid from the console\n");
		return;
	}
	if(host_client->spawned) {
		Con_Printf("prespawn not valid -- already spawned\n");
		return;
	}

	host_client->signon.state = SIGNON_SENDING;
	host_client->signon.id = 0;
}

static void
Host_Spawn_f(cmd_t *c)
{
	int i;
	client_t *client;
	edict_t *ent;
	float *a;

	USED(c);
	if(cmd_source == src_command) {
		Con_Printf("spawn is not valid from the console\n");
		return;
	}
	if(host_client->spawned) {
		Con_Printf("Spawn not valid -- already spawned\n");
		return;
	}

	// run the entrance script
	if(sv.loadgame) {
		// loaded games are fully inited already
		// if this is the last client to be connected, unpause
		sv.paused = false;
	} else {
		// set up the edict
		ent = host_client->edict;

		memset(&ent->v, 0, sv.pr->entityfields * 4);
		ent->v.colormap = NUM_FOR_EDICT(sv.pr, ent);
		ent->v.team = (host_client->colors & 15) + 1;
		ent->v.netname = PR_SetStr(sv.pr, host_client->name);

		// copy spawn parms out of the client_t

		for(i = 0; i < Nparms; i++)
			(&sv.pr->global_struct->parm1)[i] = host_client->spawn_parms[i];

		// call the spawn function

		sv.pr->global_struct->time = sv.time;
		sv.pr->global_struct->self = EDICT_TO_PROG(sv.pr, sv_player);
		PR_ExecuteProgram(sv.pr, sv.pr->global_struct->ClientConnect);

		if((dtime() - host_client->netconnection->connecttime) <= sv.time)
			Con_DPrintf("%s entered the game\n", host_client->name);

		PR_ExecuteProgram(sv.pr, sv.pr->global_struct->PutClientInServer);
	}

	// send all current names, colors, and frag counts
	SZ_Clear(&host_client->message);

	// send time of update
	MSG_WriteByte(&host_client->message, svc_time);
	MSG_WriteFloat(&host_client->message, sv.time);

	for(i = 0, client = svs.clients; i < svs.maxclients; i++, client++) {
		MSG_WriteByte(&host_client->message, svc_updatename);
		MSG_WriteByte(&host_client->message, i);
		MSG_WriteString(&host_client->message, client->name);
		MSG_WriteByte(&host_client->message, svc_updatefrags);
		MSG_WriteByte(&host_client->message, i);
		MSG_WriteShort(&host_client->message, client->old_frags);
		MSG_WriteByte(&host_client->message, svc_updatecolors);
		MSG_WriteByte(&host_client->message, i);
		MSG_WriteByte(&host_client->message, client->colors);
	}

	// send all current light styles
	for(i = 0; i < Nlights; i++) {
		MSG_WriteByte(&host_client->message, svc_lightstyle);
		MSG_WriteByte(&host_client->message, (char)i);
		MSG_WriteString(&host_client->message, sv.lightstyles[i]);
	}

	// send some stats
	MSG_WriteByte(&host_client->message, svc_updatestat);
	MSG_WriteByte(&host_client->message, STAT_TOTALSECRETS);
	MSG_WriteLong(&host_client->message, sv.pr->global_struct->total_secrets);

	MSG_WriteByte(&host_client->message, svc_updatestat);
	MSG_WriteByte(&host_client->message, STAT_TOTALMONSTERS);
	MSG_WriteLong(&host_client->message, sv.pr->global_struct->total_monsters);

	MSG_WriteByte(&host_client->message, svc_updatestat);
	MSG_WriteByte(&host_client->message, STAT_SECRETS);
	MSG_WriteLong(&host_client->message, sv.pr->global_struct->found_secrets);

	MSG_WriteByte(&host_client->message, svc_updatestat);
	MSG_WriteByte(&host_client->message, STAT_MONSTERS);
	MSG_WriteLong(&host_client->message, sv.pr->global_struct->killed_monsters);

	// send a fixangle
	// Never send a roll angle, because savegames can catch the server
	// in a state where it is expecting the client to correct the angle
	// and it won't happen if the game was just loaded, so you wind up
	// with a permanent head tilt
	ent = EDICT_NUM(sv.pr, 1 + (host_client - svs.clients));
	MSG_WriteByte(&host_client->message, svc_setangle);
	a = sv.loadgame ? ent->v.v_angle : ent->v.angles;
	for(i = 0; i < 2; i++)
		sv.protocol->MSG_WriteAngle(&host_client->message, a[i]);
	sv.protocol->MSG_WriteAngle(&host_client->message, 0);

	SV_WriteClientdataToMessage(sv_player, &host_client->message);

	MSG_WriteByte(&host_client->message, svc_signonnum);
	MSG_WriteByte(&host_client->message, 3);
	host_client->signon.state = SIGNON_KICK;
}

static void
Host_Begin_f(cmd_t *c)
{
	USED(c);
	if(cmd_source == src_command) {
		Con_Printf("begin is not valid from the console\n");
		return;
	}

	host_client->spawned = true;
}

static void
savecomment(char *cm)
{
	char *s, *p, *e;

	s = cm;
	e = cm + Nsavcm - 1;
	memset(s, '_', e - s);
	p = seprint(s, e + 1, "%s", cl.levelname);
	if(p < e)
		*p = '_';
	while(p >= s) {
		if(*p == ' ')
			*p = '_'; /* because scanf */
		p--;
	}
	p = seprint(
		s + 22, e + 1, "kills:%3d/%3d", cl.stats[STAT_MONSTERS], cl.stats[STAT_TOTALMONSTERS]
	);
	if(p < e)
		*p = '_';
	*e = 0;
}

static void
savegame(cmd_t *cmd)
{
	char *s, cm[Nsavcm];
	const char *a;
	client_t *c, *e;

	USED(cmd);
	if(cmd_source != src_command)
		return;
	else if(!sv.active) {
		Con_Printf("savegame: not a local game\n");
		return;
	} else if(cl.intermission) {
		Con_Printf("savegame: intermission in progress\n");
		return;
	} else if(svs.maxclients != 1) {
		Con_Printf("savegame: multiplayer game in progress\n");
		return;
	} else if(Cmd_Argc() != 2) {
		Con_Printf("save <savename> : save a game\n");
		return;
	} else if(strstr(Cmd_Argv(1), "..") != nil) {
		Con_Printf("savegame: invalid path\n");
		return;
	}
	c = svs.clients;
	e = c + svs.maxclients;
	while(c < e) {
		if(c->active && c->edict->v.health <= 0) {
			Con_Printf("savegame: extant dead client\n");
			return;
		}
		c++;
	}
	a = Cmd_Argv(1);
	s = va("%s/%s%s", fsdir, a, ext(a, ".sav"));
	Con_Printf("Writing game to %s\n", s);
	savecomment(cm);
	if(dumpsav(s, cm) < 0)
		Con_Printf("savegame: %s\n", lerr());
}

static void
loadgame(cmd_t *c)
{
	const char *a;
	char *s;

	if(cmd_source != src_command)
		return;
	if(Cmd_Argc() != 2) {
		Con_Printf("load <savename> : load a game\n");
		return;
	}
	cls.demonum = -1;
	a = Cmd_Argv(1);
	s = va("%s/%s%s", fsdir, a, ext(a, ".sav"));
	/* Can't call SCR_BeginLoadingPlaque, because too much stack space has
	 * been used.  The menu calls it before stuffing loadgame command */
	SCR_BeginLoadingPlaque();
	Con_DPrintf("loadgame: reading from %s", s);
	if(loadsav(s) < 0) {
		Con_Printf("loadgame: %s\n", lerr());
		return;
	}
	if(cls.state != ca_dedicated) {
		CL_EstablishConnection("local");
		reconnect(c);
	}
}

static void
Host_Kick_f(cmd_t *c)
{
	const char *who, *message = nil;
	bool byNumber = false;
	client_t *save;
	int i;

	USED(c);
	if(cmd_source == src_command) {
		if(!sv.active) {
			Cmd_ForwardToServer(nil);
			return;
		}
	} else if(sv.pr->global_struct->deathmatch)
		return;

	save = host_client;

	if(Cmd_Argc() > 2 && strcmp(Cmd_Argv(1), "#") == 0) {
		i = atof(Cmd_Argv(2)) - 1;
		if(i < 0 || i >= svs.maxclients)
			return;
		if(!svs.clients[i].active)
			return;
		host_client = &svs.clients[i];
		byNumber = true;
	} else {
		for(i = 0, host_client = svs.clients; i < svs.maxclients; i++, host_client++) {
			if(!host_client->active)
				continue;
			if(cistrcmp(host_client->name, Cmd_Argv(1)) == 0)
				break;
		}
	}

	if(i < svs.maxclients) {
		if(cmd_source == src_command)
			if(cls.state == ca_dedicated)
				who = "Console";
			else
				who = cl_name.string;
		else
			who = save->name;

		// can't kick yourself!
		if(host_client == save)
			return;

		if(Cmd_Argc() > 2) {
			message = COM_Parse(Cmd_Args());
			if(byNumber) {
				message++; // skip the #
				while(*message == ' ') // skip white space
					message++;
				message += strlen(Cmd_Argv(2)); // skip the number
			}
			while(*message && *message == ' ')
				message++;
		}
		if(message)
			SV_ClientPrintf("Kicked by %s: %s\n", who, message);
		else
			SV_ClientPrintf("Kicked by %s\n", who);
		SV_DropClient(false);
	}

	host_client = save;
}

static void
Host_Give_f(cmd_t *c)
{
	const char *t;
	int v;
	eval_t *val;

	USED(c);
	if(cmd_source == src_command) {
		Cmd_ForwardToServer(nil);
		return;
	}

	if(sv.pr->global_struct->deathmatch)
		return;

	t = Cmd_Argv(1);
	v = atoi(Cmd_Argv(2));

	switch(t[0]) {
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
		// MED 01/04/97 added hipnotic give stuff
		if(hipnotic) {
			if(t[0] == '6') {
				if(t[1] == 'a')
					sv_player->v.items = (int)sv_player->v.items | HIT_PROXIMITY_GUN;
				else
					sv_player->v.items = (int)sv_player->v.items | IT_GRENADE_LAUNCHER;
			} else if(t[0] == '9')
				sv_player->v.items = (int)sv_player->v.items | HIT_LASER_CANNON;
			else if(t[0] == '0')
				sv_player->v.items = (int)sv_player->v.items | HIT_MJOLNIR;
			else if(t[0] >= '2')
				sv_player->v.items = (int)sv_player->v.items | (IT_SHOTGUN << (t[0] - '2'));
		} else {
			if(t[0] >= '2')
				sv_player->v.items = (int)sv_player->v.items | (IT_SHOTGUN << (t[0] - '2'));
		}
		break;

	case 's':
		if(rogue) {
			val = GetEdictFieldValue(sv.pr, sv_player, ammo_shells1);
			if(val)
				val->_float = v;
		}
		sv_player->v.ammo_shells = v;
		break;

	case 'n':
		if(rogue) {
			val = GetEdictFieldValue(sv.pr, sv_player, ammo_nails1);
			if(val) {
				val->_float = v;
				if(sv_player->v.weapon <= IT_LIGHTNING)
					sv_player->v.ammo_nails = v;
			}
		} else {
			sv_player->v.ammo_nails = v;
		}
		break;

	case 'l':
		if(rogue) {
			val = GetEdictFieldValue(sv.pr, sv_player, ammo_lava_nails);
			if(val) {
				val->_float = v;
				if(sv_player->v.weapon > IT_LIGHTNING)
					sv_player->v.ammo_nails = v;
			}
		}
		break;

	case 'r':
		if(rogue) {
			val = GetEdictFieldValue(sv.pr, sv_player, ammo_rockets1);
			if(val) {
				val->_float = v;
				if(sv_player->v.weapon <= IT_LIGHTNING)
					sv_player->v.ammo_rockets = v;
			}
		} else {
			sv_player->v.ammo_rockets = v;
		}
		break;

	case 'm':
		if(rogue) {
			val = GetEdictFieldValue(sv.pr, sv_player, ammo_multi_rockets);
			if(val) {
				val->_float = v;
				if(sv_player->v.weapon > IT_LIGHTNING)
					sv_player->v.ammo_rockets = v;
			}
		}
		break;

	case 'h':
		sv_player->v.health = v;
		break;

	case 'c':
		if(rogue) {
			val = GetEdictFieldValue(sv.pr, sv_player, ammo_cells1);
			if(val) {
				val->_float = v;
				if(sv_player->v.weapon <= IT_LIGHTNING)
					sv_player->v.ammo_cells = v;
			}
		} else {
			sv_player->v.ammo_cells = v;
		}
		break;

	case 'p':
		if(rogue) {
			val = GetEdictFieldValue(sv.pr, sv_player, ammo_plasma);
			if(val) {
				val->_float = v;
				if(sv_player->v.weapon > IT_LIGHTNING)
					sv_player->v.ammo_cells = v;
			}
		}
		break;
	}
}

static edict_t *
FindViewthing(void)
{
	int i;
	edict_t *e;

	for(i = 0; i < sv.pr->num_edicts; i++) {
		e = EDICT_NUM(sv.pr, i);
		if(strcmp(PR_Str(sv.pr, e->v.classname), "viewthing") == 0)
			return e;
	}
	Con_Printf("No viewthing on map\n");
	return nil;
}

static void
Host_Viewmodel_f(cmd_t *c)
{
	edict_t *e;
	model_t *m;

	USED(c);
	e = FindViewthing();
	if(!e)
		return;

	m = Mod_ForName(Cmd_Argv(1), false);
	if(!m) {
		Con_Printf("Can't load %s\n", Cmd_Argv(1));
		return;
	}

	e->v.frame = 0;
	cl.model_precache[(int)e->v.modelindex] = m;
}

static void
Host_Viewframe_f(cmd_t *c)
{
	model_t *m;
	edict_t *e;
	int f;

	USED(c);
	e = FindViewthing();
	if(!e)
		return;
	m = cl.model_precache[(int)e->v.modelindex];

	f = atoi(Cmd_Argv(1));
	if(f >= m->numframes)
		f = m->numframes - 1;

	e->v.frame = f;
}

static void
PrintFrameName(model_t *m, int frame)
{
	aliashdr_t *hdr;
	maliasframedesc_t *pframedesc;

	hdr = (aliashdr_t *)Mod_Extradata(m);
	if(!hdr)
		return;
	pframedesc = &hdr->frames[frame];

	Con_Printf("frame %d: %s\n", frame, pframedesc->name);
}

static void
Host_Viewnext_f(cmd_t *c)
{
	edict_t *e;
	model_t *m;

	USED(c);
	e = FindViewthing();
	if(!e)
		return;
	m = cl.model_precache[(int)e->v.modelindex];

	e->v.frame = e->v.frame + 1;
	if(e->v.frame >= m->numframes)
		e->v.frame = m->numframes - 1;

	PrintFrameName(m, e->v.frame);
}

static void
Host_Viewprev_f(cmd_t *c)
{
	edict_t *e;
	model_t *m;

	USED(c);
	e = FindViewthing();
	if(!e)
		return;

	m = cl.model_precache[(int)e->v.modelindex];

	e->v.frame = e->v.frame - 1;
	if(e->v.frame < 0)
		e->v.frame = 0;

	PrintFrameName(m, e->v.frame);
}

static void
Host_Startdemos_f(cmd_t *cmd)
{
	int i, c;

	USED(cmd);
	if(cls.state == ca_dedicated) {
		if(!sv.active)
			Cbuf_AddText("map start\n");
		return;
	}

	c = Cmd_Argc() - 1;
	if(c > MAX_DEMOS) {
		Con_Printf("Max %d demos in demoloop\n", MAX_DEMOS);
		c = MAX_DEMOS;
	}
	Con_Printf("%d demo(s) in loop\n", c);

	for(i = 1; i < c + 1; i++)
		strncpy(cls.demos[i - 1], Cmd_Argv(i), sizeof(cls.demos[0]) - 1);

	if(!sv.active && cls.demonum != -1 && !cls.demoplayback) {
		cls.demonum = 0;
		CL_NextDemo();
	} else
		cls.demonum = -1;
}

/* Return to looping demos */
static void
Host_Demos_f(cmd_t *c)
{
	USED(c);
	if(cls.state == ca_dedicated)
		return;
	if(cls.demonum == -1)
		cls.demonum = 1;
	CL_Disconnect_f(nil);
	CL_NextDemo();
}

static void
Host_Stopdemo_f(cmd_t *c)
{
	USED(c);
	if(cls.state == ca_dedicated)
		return;
	if(!cls.demoplayback)
		return;
	abortdemo();
	CL_Disconnect();
}

void
Host_InitCommands(void)
{
	Cmd_AddCommand("status", Host_Status_f);
	Cmd_AddCommand("quit", Host_Quit_f);
	Cmd_AddCommand("god", Host_God_f);
	Cmd_AddCommand("notarget", Host_Notarget_f);
	Cmd_AddCommand("fly", Host_Fly_f);
	Cmd_AddCommand("map", Host_Map_f);
	Cmd_AddCommand("restart", Host_Restart_f);
	Cmd_AddCommand("changelevel", Host_Changelevel_f);
	Cmd_AddCommand("connect", Host_Connect_f);
	Cmd_AddCommand("reconnect", reconnect);
	Cmd_AddCommand("name", Host_Name_f);
	Cmd_AddCommand("noclip", Host_Noclip_f);
	Cmd_AddCommand("version", Host_Version_f);
	Cmd_AddCommand("say", Host_Say_f);
	Cmd_AddCommand("say_team", Host_Say_Team_f);
	Cmd_AddCommand("tell", Host_Tell_f);
	Cmd_AddCommand("color", Host_Color_f);
	Cmd_AddCommand("kill", Host_Kill_f);
	Cmd_AddCommand("pause", Host_Pause_f);
	Cmd_AddCommand("spawn", Host_Spawn_f);
	Cmd_AddCommand("begin", Host_Begin_f);
	Cmd_AddCommand("prespawn", Host_PreSpawn_f);
	Cmd_AddCommand("kick", Host_Kick_f);
	Cmd_AddCommand("ping", Host_Ping_f);
	Cmd_AddCommand("load", loadgame);
	Cmd_AddCommand("save", savegame);
	Cmd_AddCommand("give", Host_Give_f);
	Cmd_AddCommand("startdemos", Host_Startdemos_f);
	Cmd_AddCommand("demos", Host_Demos_f);
	Cmd_AddCommand("stopdemo", Host_Stopdemo_f);
	Cmd_AddCommand("viewmodel", Host_Viewmodel_f);
	Cmd_AddCommand("viewframe", Host_Viewframe_f);
	Cmd_AddCommand("viewnext", Host_Viewnext_f);
	Cmd_AddCommand("viewprev", Host_Viewprev_f);
	Cmd_AddCommand("mcache", Mod_Print_f);
}