Esempio n. 1
3
/*
===============
Cmd_Vstr_f

Inserts the current value of a variable as command text
===============
*/
void Cmd_Vstr_f( void ) {
	char	*v;

	if (Cmd_Argc () != 2) {
		Com_Printf ("vstr <variablename> : execute a variable command\n");
		return;
	}

	v = Cvar_VariableString( Cmd_Argv( 1 ) );
	Cbuf_InsertText( va("%s\n", v ) );
}
Esempio n. 2
3
/*
============
Cmd_ExecuteString

A complete command line has been parsed, so try to execute it
FIXME: lookupnoadd the token to speed search?
============
*/
void Cmd_ExecuteString(const char * text)
{
    extern void Cmd_ForwardToServer(void);

    cmd_function_t * cmd;
    cmdalias_t * a;

    Cmd_TokenizeString(text, true);

    // execute the command line
    if (!Cmd_Argc())
        return; // no tokens

    // check functions
    for (cmd = cmd_functions; cmd; cmd = cmd->next)
    {
        if (!Q_strcasecmp(cmd_argv[0], cmd->name))
        {
            if (!cmd->function)
            {
                // forward to server command
                Cmd_ExecuteString(va("cmd %s", text));
            }
            else
            {
                cmd->function();
            }
            return;
        }
    }

    // check alias
    for (a = cmd_alias; a; a = a->next)
    {
        if (!Q_strcasecmp(cmd_argv[0], a->name))
        {
            if (++alias_count == ALIAS_LOOP_COUNT)
            {
                Com_Printf("ALIAS_LOOP_COUNT\n");
                return;
            }
            Cbuf_InsertText(a->value);
            return;
        }
    }

    // check cvars
    if (Cvar_Command())
        return;

    // send it as a server command if we are connected
    Cmd_ForwardToServer();
}
Esempio n. 3
2
/*
============
Cmd_ExecuteString

A complete command line has been parsed, so try to execute it
============
*/
void Cmd_ExecuteString( char *text, cmd_source_t src )
{	
	qboolean		isServerCommand = false;
	qboolean		isDLLCommand = false;
	cmd_function_t	*cmd;
	cmdalias_t	*a;

	// set cmd source
	cmd_source = src;
	
	// execute the command line
	Cmd_TokenizeString( text );		

	if( !Cmd_Argc()) return; // no tokens

	// check alias
	for( a = cmd_alias; a; a = a->next )
	{
		if( !Q_stricmp( cmd_argv[0], a->name ))
		{
			Cbuf_InsertText( a->value );
			return;
		}
	}

	// check functions
	for( cmd = cmd_functions; cmd; cmd = cmd->next )
	{
		if( cmd && !Q_stricmp( cmd_argv[0], cmd->name ) && cmd->function )
		{
			cmd->function();
			return;
		}
	}

	// check cvars
	if( Cvar_Command( )) return;

	// forward the command line to the server, so the entity DLL can parse it
	if( cmd_source == src_command && host.type == HOST_NORMAL )
	{
		if( cls.state >= ca_connected )
		{
			Cmd_ForwardToServer();
			return;
		}
	}
	else if( text[0] != '@' && host.type == HOST_NORMAL )
	{
		// commands with leading '@' are hidden system commands
		MsgDev( D_INFO, "Unknown command \"%s\"\n", text );
	}
}
Esempio n. 4
0
/**
 * @brief A complete command line has been parsed, so try to execute it
 * @todo lookupnoadd the token to speed search?
 */
void Cmd_ExecuteString (const char *text)
{
	const cmd_function_t *cmd;
	const cmd_alias_t *a;
	const char *str;
	unsigned int hash;

	Com_DPrintf(DEBUG_COMMANDS, "ExecuteString: '%s'\n", text);

	Cmd_TokenizeString(text, qtrue);

	/* execute the command line */
	if (!Cmd_Argc())
		/* no tokens */
		return;

	str = Cmd_Argv(0);

	/* check functions */
	hash = Com_HashKey(str, CMD_HASH_SIZE);
	for (cmd = cmd_functions_hash[hash]; cmd; cmd = cmd->hash_next) {
		if (!Q_strcasecmp(str, cmd->name)) {
			if (!cmd->function) {	/* forward to server command */
				Cmd_ExecuteString(va("cmd %s", text));
			} else {
				cmd_userdata = cmd->userdata;
				cmd->function();
			}
			return;
		}
	}

	/* check alias */
	hash = Com_HashKey(str, ALIAS_HASH_SIZE);
	for (a = cmd_alias_hash[hash]; a; a = a->hash_next) {
		if (!Q_strcasecmp(str, a->name)) {
			if (++alias_count == ALIAS_LOOP_COUNT) {
				Com_Printf("ALIAS_LOOP_COUNT\n");
				return;
			}
			Cbuf_InsertText(a->value);
			return;
		}
	}

	/* check cvars */
	if (Cvar_Command())
		return;

	/* send it as a server command if we are connected */
	Cmd_ForwardToServer();
}
Esempio n. 5
0
/*
===============
Cmd_Vstr_f

Inserts the current value of a variable as command text
===============
*/
void Cmd_Vstr_f( void ) {
	char	*v;
	char	buf[MAX_STRING_CHARS];
	
	if (Cmd_Argc () != 2) {
		Com_Printf ("vstr <variablename> : execute a variable command\n");
		return;
	}

	v = Cvar_VariableString( Cmd_Argv( 1 ) );
	Com_sprintf(buf, sizeof(buf), "%s", v);
	Cbuf_InsertText( buf );
}
Esempio n. 6
0
/*
===============
Cmd_If_f

Compares two values, if true executes the third argument, if false executes the forth
===============
*/
void Cmd_If_f( void ) {
	char	*v;
	int 	v1;
	int 	v2;
	char	*vt;
	char	*vf;
	char  *op;

	if ( (Cmd_Argc () == 6 ) || (Cmd_Argc () == 5) ) {
		v1 = atoi( Cmd_Argv( 1 ) );
		op = Cmd_Argv( 2 );
		v2 = atoi( Cmd_Argv( 3 ) );
		vt = Cmd_Argv( 4 );
		if ( ( !strcmp( op, "="  ) && v1 == v2 ) ||
			( !strcmp( op, "!=" ) && v1 != v2 ) ||
			( !strcmp( op, "<"  ) && v1 <  v2 ) ||
			( !strcmp( op, "<=" ) && v1 <= v2 ) ||
			( !strcmp( op, ">"  ) && v1 >  v2 ) ||
			( !strcmp( op, ">=" ) && v1 >= v2 ) )
		{
			v = vt;
		}
		else if ( ( !strcmp( op, "="  ) && v1 != v2 ) ||
			( !strcmp( op, "!=" ) && v1 == v2 ) ||
			( !strcmp( op, "<"  ) && v1 >= v2 ) ||
			( !strcmp( op, "<=" ) && v1 >  v2 ) ||
			( !strcmp( op, ">"  ) && v1 <= v2 ) ||
			( !strcmp( op, ">=" ) && v1 <  v2 ) )
		{
			if ( Cmd_Argc () == 6 ) 
			{
				vf = Cmd_Argv( 5 );
				v = vf;
			}
			else
			{
				return;
			}
		}
		else
		{
			Com_Printf ("invalid operator in if command. valid operators are = != < > >= <=\n");
			return;
		}
	}
	else {
		Com_Printf ("if <value1> <operator> <value2> <cmdthen> (<cmdelse>) : compares the first two values and executes <cmdthen> if true, <cmdelse> if false\n");
		return;
	}
	Cbuf_InsertText( va("vstr %s\n", v ) );
}
Esempio n. 7
0
/*
===============
Cmd_Vstr_f

Inserts the current value of a variable as command text
===============
*/
void Cmd_Vstr_f( void ) {
	const char	*v;
	char	buf[MAX_CMD_LINE];
	char c_str[1024];

	if (Cmd_Argc () != 2) {
		Com_Printf ("vstr <variablename> : execute a variable command\n");
		return;
	}

	v = Cvar_VariableStringBuffer( Cmd_Argv( 1 ), c_str, sizeof(c_str) );
	Com_sprintf(buf, sizeof(buf), "%s", v);
	Cbuf_InsertText( buf );
}
Esempio n. 8
0
/*
===============
Host_Exec_f
===============
*/
void Host_Exec_f( void )
{
	string	cfgpath;
	char	*f;

	if( Cmd_Argc() != 2 )
	{
		Msg( "Usage: exec <filename>\n" );
		return;
	}

	// HACKHACK: don't execute listenserver.cfg in singleplayer
	if( !Q_stricmp( Cvar_VariableString( "lservercfgfile" ),  Cmd_Argv( 1 )))
	{
		if( Cvar_VariableValue( "maxplayers" ) == 1.0f )
			return;
	}

	Q_strncpy( cfgpath, Cmd_Argv( 1 ), sizeof( cfgpath )); 
	FS_DefaultExtension( cfgpath, ".cfg" ); // append as default

	f = (char *)FS_LoadFile( cfgpath, NULL, false );
	if( !f )
	{
		MsgDev( D_NOTE, "couldn't exec %s\n", Cmd_Argv( 1 ));
		return;
	}

	MsgDev( D_INFO, "execing %s\n", Cmd_Argv( 1 ));

	// terminate the string with newline just in case it's missing
	// insertion order is backwards from execution order
	Cbuf_InsertText( "\n" );
	Cbuf_InsertText( f );
	Mem_Free( f );
}
Esempio n. 9
0
static void
Cmd_Runalias_f (void)
{
	cmdalias_t *a;

	a = (cmdalias_t *) Hash_Find (cmd_alias_hash, Cmd_Argv (0));

	if (a) {
		Cbuf_InsertText (cbuf_active, a->value);
		return;
	} else {
		Sys_Printf
			("BUG: No alias found for registered command.  Please report this to the QuakeForge development team.");
	}
}
Esempio n. 10
0
File: cmd.c Progetto: jrk/QuakeTM
/*
============
Cmd_ExecuteString

A complete command line has been parsed, so try to execute it
FIXME: lookupnoadd the token to speed search?
============
*/
void	Cmd_ExecuteString (char *text)
{	
	cmd_function_t	*cmd;
	cmdalias_t		*a;

	Cmd_TokenizeString (text);
			
// execute the command line
	if (!Cmd_Argc())
		return;		// no tokens

// check functions
	for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
	{
		if (!Q_strcasecmp (cmd_argv[0],cmd->name))
		{
			if (!strcmp(cmd->name, "kill"))
			{
				if ((trace_state == read_trace || trace_state == write_trace)) 
				{
					trace_state = stop_trace;
					printf("GAJA: command = kill\n");
				}
			}

			if (!cmd->function)
				Cmd_ForwardToServer ();
			else
				cmd->function ();
			return;
		}
	}

// check alias
	for (a=cmd_alias ; a ; a=a->next)
	{
		if (!Q_strcasecmp (cmd_argv[0], a->name))
		{
			Cbuf_InsertText (a->value);
			return;
		}
	}
	
// check cvars
	if (!Cvar_Command () && (cl_warncmd.value || developer.value))
		Con_Printf ("Unknown command \"%s\"\n", Cmd_Argv(0));
	
}
Esempio n. 11
0
/*
===============
Cmd_StuffCmds_f

Adds command line parameters as script statements
Commands lead with a +, and continue until a - or another +
xash +prog jctest.qp +cmd amlev1
xash -nosound +cmd amlev1
===============
*/
void Cmd_StuffCmds_f( void )
{
	int	i, j, l = 0;
	char	build[MAX_MSGLEN]; // this is for all commandline options combined (and is bounds checked)

	if(Cmd_Argc() != 1)
	{
		Msg( "stuffcmds : execute command line parameters\n");
		return;
	}

	// no reason to run the commandline arguments twice
	if(Sys.stuffcmdsrun) return;

	Sys.stuffcmdsrun = true;
	build[0] = 0;

	for (i = 0; i < fs_argc; i++)
	{
		if (fs_argv[i] && fs_argv[i][0] == '+' && (fs_argv[i][1] < '0' || fs_argv[i][1] > '9') && l + strlen(fs_argv[i]) - 1 <= sizeof(build) - 1)
		{
			j = 1;
			while (fs_argv[i][j]) build[l++] = fs_argv[i][j++];

			i++;
			for ( ; i < fs_argc; i++)
			{
				if (!fs_argv[i]) continue;
				if ((fs_argv[i][0] == '+' || fs_argv[i][0] == '-') && (fs_argv[i][1] < '0' || fs_argv[i][1] > '9'))
					break;
				if (l + strlen(fs_argv[i]) + 4 > sizeof(build) - 1)
					break;
				build[l++] = ' ';
				if (strchr(fs_argv[i], ' ')) build[l++] = '\"';
				for (j = 0; fs_argv[i][j]; j++) build[l++] = fs_argv[i][j];
				if (strchr(fs_argv[i], ' ')) build[l++] = '\"';
			}
			build[l++] = '\n';
			i--;
		}
	}

	// now terminate the combined string and prepend it to the command buffer
	// we already reserved space for the terminator
	build[l++] = 0;
	Cbuf_InsertText( build );
}
Esempio n. 12
0
/*
============
Cbuf_ExecuteText
============
*/
void Cbuf_ExecuteText (int exec_when, char *text)
{
	switch (exec_when)
	{
	case EXEC_NOW:
		Cmd_ExecuteString (text);
		break;
	case EXEC_INSERT:
		Cbuf_InsertText (text);
		break;
	case EXEC_APPEND:
		Cbuf_AddText (text);
		break;
	default:
		Com_Error (ERR_FATAL, "Cbuf_ExecuteText: bad exec_when");
	}
}
Esempio n. 13
0
/*
============
Cmd_RunAlias_f
============
*/
void Cmd_RunAlias_f(void)
{
	cmd_alias_t	*alias;
	char 		*name = Cmd_Argv(0);
	char 		*args = Cmd_ArgsFrom(1);

	// Find existing alias
	for (alias = cmd_aliases; alias; alias=alias->next)
	{
		if (!Q_stricmp( name, alias->name ))
			break;
	}

	if (!alias)
		Com_Error(ERR_FATAL, "Alias: Alias %s doesn't exist", name);

	Cbuf_InsertText(va("%s %s", alias->exec, args));
}
static const char *Keys_MenuKey( int key )
{
	menuaction_s *item = ( menuaction_s * ) Menu_ItemAtCursor( &s_keys_menu );

	//pressing mouse1 to pick a new bind wont force bind/unbind itself - spaz
	if ( bind_grab && !(cursor.buttonused[MOUSEBUTTON1]&&key==K_MOUSE1))
	{	
		if ( key != K_ESCAPE && key != '`' )
		{
			char cmd[1024];

			Com_sprintf (cmd, sizeof(cmd), "bind \"%s\" \"%s\"\n", Key_KeynumToString(key), bindnames[item->generic.localdata[0]][0]);
			Cbuf_InsertText (cmd);
		}
		
		// Knightmare- added Psychospaz's mouse support
		//dont let selecting with mouse buttons screw everything up
		UI_RefreshCursorButtons();
		if (key==K_MOUSE1)
			cursor.buttonclicks[MOUSEBUTTON1] = -1;

		//Menu_SetStatusBar( &s_keys_menu, "enter to change, backspace to clear" );
		Menu_SetStatusBar( &s_keys_menu, "Press ENTER or LEFT CLICK to change the key. Press BACKSPACE to clear." );
		bind_grab = false;
		return menu_out_sound;
	}

	switch ( key )
	{
	case K_KP_ENTER:
	case K_ENTER:
		if (item == &s_keys_back_action) { // back action hack
			UI_BackMenu(item); return NULL; }
		KeyBindingFunc( item );
		return menu_in_sound;
	case K_BACKSPACE:		// delete bindings
	case K_DEL:				// delete bindings
	case K_KP_DEL:
		M_UnbindCommand( bindnames[item->generic.localdata[0]][0] );
		return menu_out_sound;
	default:
		return Default_MenuKey( &s_keys_menu, key );
	}
}
Esempio n. 15
0
/*
===============
Cmd_ExecFile
===============
*/
static void Cmd_ExecFile( char *f )
{
	int i;

	COM_Compress (f);
	
	Cvar_Get( "arg_all", Cmd_ArgsFrom(2), CVAR_TEMP | CVAR_ROM | CVAR_USER_CREATED, "" );
	Cvar_Set( "arg_all", Cmd_ArgsFrom(2) );
	Cvar_Get( "arg_count", va( "%i", Cmd_Argc() - 2 ), CVAR_TEMP | CVAR_ROM | CVAR_USER_CREATED, "" );
	Cvar_Set( "arg_count", va( "%i", Cmd_Argc() - 2 ) );

	for (i = Cmd_Argc() - 2; i; i--)
	{
		Cvar_Get( va("arg_%i", i), Cmd_Argv( i + 1 ), CVAR_TEMP | CVAR_ROM | CVAR_USER_CREATED, "" );
		Cvar_Set( va("arg_%i", i), Cmd_Argv( i + 1 ) );
	}

	Cbuf_InsertText (f);
}
Esempio n. 16
0
/*
===============
Cmd_Strcmp_f

Compares two strings, if true executes the third argument, if false executes the forth
===============
*/
void Cmd_Strcmp_f( void ) {
	char	*v;
	char 	*v1;
	char 	*v2;
	char	*vt;
	char	*vf;
	char  *op;

	if ( (Cmd_Argc () == 6 ) || (Cmd_Argc () == 5) ) {
		v1 = Cmd_Argv( 1 );
		op = Cmd_Argv( 2 );
		v2 = Cmd_Argv( 3 );
		vt = Cmd_Argv( 4 );
		if ( ( !strcmp( op, "="  ) && !strcmp( v1, v2 ) ) ||
			( !strcmp( op, "!=" ) && strcmp( v1, v2 ) ) )
		{
			v = vt;
		}
		else if ( ( !strcmp( op, "="  ) && strcmp( v1, v2 ) ) ||
			( !strcmp( op, "!=" ) && !strcmp( v1, v2 ) ) )
		{
			if ( Cmd_Argc () == 6 ) 
			{
				vf = Cmd_Argv( 5 );
				v = vf;
			}
			else
			{
				return;
			}
		}
		else
		{
			Com_Printf ("invalid operator in strcmp command. valid operators are = != \n");
			return;
		}
	}
	else {
		Com_Printf ("strcmp <string1> <operator> <string2> <cmdthen> (<cmdelse>) : compares the first two strings and executes <cmdthen> if true, <cmdelse> if false\n");
		return;
	}
	Cbuf_InsertText( va("%s\n", v ) );
}
Esempio n. 17
0
/*
==================
SV_ParseStringCommand

Client command string
==================
*/
void SV_ParseStringCommand(client_t *cl)
{
	char *s;
	int ret;

	s = MSG_ReadString();
	
	// Determine whether the command is appropriate
	ret = SV_ValidateClientCommand( s );
	switch ( ret )
	{
	case 2:
		Cbuf_InsertText (s);
		break;
	case 1:
		Cmd_ExecuteString (s, src_client);
		break;
	default:

		Cmd_TokenizeString(s);

		ConCommandBase const *pCommand = ConCommandBase::FindCommand( Cmd_Argv( 0 ) );
		if ( pCommand && pCommand->IsCommand() && pCommand->IsBitSet( FCVAR_EXTDLL ) )
		{
			// Allow cheat commands in singleplayer, debug, or multiplayer with sv_cheats on
#ifndef _DEBUG
			if ( pCommand->IsBitSet( FCVAR_CHEAT ) )
			{
				if ( svs.maxclients > 1 && sv_cheats.GetInt() == 0 )
					break;
			}
#endif

			serverGameClients->SetCommandClient( host_client - svs.clients );
			( ( ConCommand * )pCommand )->Dispatch();
		}
		else
		{
			serverGameClients->ClientCommand( sv_player );
		}
		break;
	}
}
Esempio n. 18
0
/*
====================
SV_Init
====================
*/
void SV_Init (void)
{
	Sys_Printf ("Host_Init\n");

	Memory_Init (host_parms->membase, host_parms->memsize);
	Cbuf_Init ();
	Cmd_Init ();

	COM_Init ();
	FS_Init ();

	PR_Init ();
	Mod_Init ();

	SV_InitNet ();

	SV_InitLocal ();
	Pmove_Init ();

	Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
	host_hunklevel = Hunk_LowMark ();

	Cbuf_InsertText ("exec server.cfg\n");
	Cbuf_Execute ();
	// unlock the early-set cvars after init
	Cvar_UnlockAll ();

	host_initialized = true;

	Con_Printf ("Exe: "__TIME__" "__DATE__"\n");
	Con_Printf ("%4.1f megabyte heap\n", host_parms->memsize/(1024*1024.0));
	Con_Printf ("======== HexenWorld Initialized ========\n");

	// process command line arguments
	Cmd_StuffCmds_f ();
	Cbuf_Execute ();

	// if a map wasn't specified on the command line, spawn demo1.map
	if (sv.state == ss_dead)
		Cmd_ExecuteString ("map demo1", src_command);
	if (sv.state == ss_dead)
		SV_Error ("Couldn't spawn a server");
}
Esempio n. 19
0
/*
============
Cbuf_ExecuteText
============
*/
void Cbuf_ExecuteText( int exec_when, const char *text ) {
	switch ( exec_when )
	{
	case EXEC_NOW:
		if ( text && strlen( text ) > 0 ) {
			Cmd_ExecuteString( text );
		} else {
			Cbuf_Execute();
		}
		break;
	case EXEC_INSERT:
		Cbuf_InsertText( text );
		break;
	case EXEC_APPEND:
		Cbuf_AddText( text );
		break;
	default:
		Com_Error( ERR_FATAL, "Cbuf_ExecuteText: bad exec_when" );
	}
}
Esempio n. 20
0
/*
============
Cbuf_ExecuteText
============
*/
void Cbuf_ExecuteText( int exec_when, const char *text )
{
	switch( exec_when )
	{
	case EXEC_NOW:
		if( text && com.strlen( text ))
			Cmd_ExecuteString( text );
		else Cbuf_Execute();
		break;
	case EXEC_INSERT:
		Cbuf_InsertText( text );
		break;
	case EXEC_APPEND:
		Cbuf_AddText( text );
		break;
	default:
		MsgDev( D_ERROR, "Cbuf_ExecuteText: bad execute target\n" );
		break;
	}
}
Esempio n. 21
0
/*
-----------------------------------------------------------------------------
 Function: Cbuf_ExecuteText -Execute string.
 
 Parameters: exec_when -[in] see execwhen_t definition.
			 text -[in] string with command to execute.
 Returns:
 
 Notes: 

-----------------------------------------------------------------------------
*/
PUBLIC void Cbuf_ExecuteText( execwhen_t exec_when, char *text )
{
	switch( exec_when )
	{
		case EXEC_NOW:
			Cmd_ExecuteString( text );
			break;

		case EXEC_INSERT:
			Cbuf_InsertText( text );
			break;

		case EXEC_APPEND:
			Cbuf_AddText( text );
			break;

		default:
			Com_DPrintf( "Cbuf_ExecuteText: bad exec_when" );
	}
}
Esempio n. 22
0
/*
** Start next demo in loop
*/
void CL_NextDemo (void)
{
	if (!cls.playdemos)
		return;

	cls.demonum++;
	if (cls.demonum >= MAX_DEMOS || !cls.demos[cls.demonum][0])
	{
		if (cls.playdemos == 2)
			cls.demonum = 0;		// start again
		else {
			// stop demo loop
			cls.playdemos = 0;
			return;
		}
	}

	SCR_BeginLoadingPlaque ();	// ok to call here?
	Cbuf_InsertText (va("playdemo \"%s\"\n", cls.demos[cls.demonum]));
}
Esempio n. 23
0
//cbase
//These last few functions are the highest level wrappers.
int Init(char * path, char * argv) {

   char temp[0x100];

   if(TestStructureAlignment() == 0) { return(0); }
   Sys_InitArgv(argv);

   if(FileSystem_Init(path) == 0) { return(0); }
   if(Sys_InitGame() == 0) { return(0); }

   Q_snprintf(temp, sizeof(temp)-1, "exec %s\n", cvar_servercfgfile.string);
   temp[sizeof(temp)-1] = '\0';
   Cbuf_InsertText(temp);

   #ifdef USE_timeGetTime
    timeBeginPeriod(1);
   #endif

   return(1);
}
Esempio n. 24
0
void EXT_FUNC Cmd_ExecuteString_internal(const char* cmdName, cmd_source_t src, IGameClient* client) {
	// Search in functions
	cmd_function_t *cmd = cmd_functions;
	while (cmd)
	{
		if (!Q_stricmp(cmd_argv[0], cmd->name))
		{
			cmd->function();

			if (g_pcls.demorecording && (cmd->flags & FCMD_HUD_COMMAND) && !g_pcls.spectator)
			{
				CL_RecordHUDCommand(cmd->name);
			}

			return;
		}

		cmd = cmd->next;
	}

	// Search in aliases
	cmdalias_t *a = cmd_alias;
	while (a)
	{
		if (!Q_stricmp(cmd_argv[0], a->name))
		{

			Cbuf_InsertText(a->value);
			return;
		}

		a = a->next;
	}

	// Search in cvars
	if (!Cvar_Command() && g_pcls.state >= ca_connected)
	{
		// Send to a server if nothing processed locally and connected
		Cmd_ForwardToServer();
	}
}
Esempio n. 25
0
// don't forward the first argument
static void
CL_Cmd_ForwardToServer_f (void)
{
	if (cls.state == ca_disconnected) {
		Sys_Printf ("Can't \"%s\", not connected\n", Cmd_Argv (0));
		return;
	}

	if (strcasecmp (Cmd_Argv (1), "snap") == 0) {
		Cbuf_InsertText (cl_cbuf, "snap\n");
		return;
	}

	if (cls.demoplayback)
		return;							// not really connected

	if (Cmd_Argc () > 1) {
		MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
		SZ_Print (&cls.netchan.message, Cmd_Args (1));
	}
}
Esempio n. 26
0
/*
==============
SV_Save_f

==============
*/
void SV_Save_f( void )
{
	const char *name;

	switch( Cmd_Argc() )
	{
	case 1: name = "new"; break;
	case 2: name = Cmd_Argv( 1 ); break;
	default:
		Msg( "Usage: save <savename>\n" );
		return;
	}

	if( host_xashds_hacks->value )
	{
		Cbuf_InsertText(va("rcon save %s\n", Cmd_Argv( 1 )));
		return;
	}

	SV_SaveGame( name );
}
Esempio n. 27
0
/**
 * Called to play the next demo in the demo loop
 */
void CL_NextDemo(void) {
	char str[1024];

	if (cls.demonum == -1)
		return; // don't play demos

	SCR_BeginLoadingPlaque();

	if (!cls.demos[cls.demonum][0] || cls.demonum == MAX_DEMOS) {
		cls.demonum = 0;
		if (!cls.demos[cls.demonum][0]) {
			Con_Printf("No demos listed with startdemos\n");
			cls.demonum = -1;
			return;
		}
	}

	sprintf(str, "playdemo %s\n", cls.demos[cls.demonum]);
	Cbuf_InsertText(str);
	cls.demonum++;
}
Esempio n. 28
0
/*
=====================
CL_NextDemo

Called to play the next demo in the demo loop
=====================
*/
void CL_NextDemo (void)
{
	char	str[MAX_INPUTLINE];

	if (cls.demonum == -1)
		return;		// don't play demos

	if (!cls.demos[cls.demonum][0] || cls.demonum == MAX_DEMOS)
	{
		cls.demonum = 0;
		if (!cls.demos[cls.demonum][0])
		{
			Con_Print("No demos listed with startdemos\n");
			cls.demonum = -1;
			return;
		}
	}

	dpsnprintf (str, sizeof(str), "playdemo %s\n", cls.demos[cls.demonum]);
	Cbuf_InsertText (str);
	cls.demonum++;
}
Esempio n. 29
0
void Cmd_Exec_f( void ) {
	char *f;
	char filename[MAX_QPATH];

	if ( Cmd_Argc() != 2 ) {
		Com_Printf( "exec <filename> : execute a script file\n" );
		return;
	}

	Q_strncpyz( filename, Cmd_Argv( 1 ), sizeof( filename ) );
	COM_DefaultExtension( filename, sizeof( filename ), ".cfg" );
	FS_ReadFile( filename, (void **)&f );
	if ( !f ) {
		Com_Printf( "couldn't exec %s\n",Cmd_Argv( 1 ) );
		return;
	}
	Com_Printf( "execing %s\n",Cmd_Argv( 1 ) );

	Cbuf_InsertText( f );

	FS_FreeFile( f );
}
Esempio n. 30
0
/*
============
Cmd_ExecuteString

A complete command line has been parsed, so try to execute it
FIXME: lookupnoadd the token to speed search?
============
*/
void	Cmd_ExecuteString (char *text, cmd_source_t src)
{	
	cmd_function_t	*cmd;
	cmdalias_t	*a;

	cmd_source = src;
	Cmd_TokenizeString (text);

			
// execute the command line
	if (!Cmd_Argc())
		return;		// no tokens

// check functions
	
	for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
	{
		if (!Q_strcasecmp (cmd_argv[0],cmd->name))
		{
			cmd->function ();
			return;
		}
	}

// check alias
	for (a=cmd_alias ; a ; a=a->next)
	{
		if (!Q_strcasecmp (cmd_argv[0], a->name))
		{
			Cbuf_InsertText (a->value);
			return;
		}
	}
	
// check cvars
	if (!Cvar_Command ())
		Con_Printf ("Unknown command \"%s\"\n", Cmd_Argv(0));
	
}