SUBJECT
	quicktyper

DESCRIPTION
	StickMud and built in quicktyper and command line handling.
	Every line is processed before it leaves out to be used as
	a command. Command line processing allows multiple commands
	on a single line, argument variables, full command and alias
	recursion and command queues. Recalling past commands is also
	possible with history control. 

!	Quicktyper can be escaped with '\' character in the beginning 
!	of the line.

	Command line structure can be detailed as follows:

	<command> <word> <word> ...

	The quicktyper allows aliased commands and words. Command
	and word aliases are set with two separate commands:

	'command' and 'alias'

	'command' is used to set aliases for <command> part of the
	input line. And 'alias' sets aliases for <word> parts.

MULTIPLE COMMANDS:
	Command line is separated by a special strings to tell the
	quicktyper where the command line is desired to end.

	west ; east ; south

	The command line is separated by delimiter ';'. The quicktyper
	sees this one single line as three as if <enter> was pressed
	at the place of the delimiter. Delimiter can be changed by
	the user with 'command'. See help on 'command' to find out
	how. Maximum commands on one line is currently 10.

	Single commands can be multiplied with number argument preceeding
	the actual command:

	3 bounce

	Command makes you bounce three times. Current maximum is 5.

ARGUMENT VARIALBLES
	The input line can be pointed with built in variables when
	a command alias is used. Let's pretend there is a command
	alias as follows:

	pp = put $1 in bag $2

	Now the command can be used like this:

	pp sword 1

	which traslates to:

	put sword in bag 1

	If argument was not given, nothing is substituted in place of
	$ variable.

	A special variable '$*' can be used to point at the rest of
	the command arguments not pointed yet. Currently it can be
	called once in one command.

	foo = say foo $2 $*

	Command line could look as follows:

	foo a b c d e f g

	It translates to:

	say foo b a c d e f g

RECURSION
	Command aliases and aliases can be recursively defined.
	Defined command aliases can inhold already defined words.

	foo = say hello
	s   = foo to you too

	Command 's' translates to:

	say hello to you too

	Recursion is limited to prevent loops continuing forever.

COMMAND QUEUES
	Commands get queued when a timed action takes place. At the
	moment multiple commands with movements are delayed to avoid
	instant moving from place to place. Single movement commands
	are not delayed. Example:

	w ; w ; w ; s ; jump ; grin ; n

	First the movement commands are delayed (1/beat), then 'jump'
	and 'grin' are done instantly, after those 'n' is delayed.
	Any single command inserted will end up to the command
        queue if other commands are still executing.

	This method ensures that the commands are executed in the
	same exact order they were given. Queue can be dropped at
	will (see dq).

HISTORY REFERENCING
	Past commands can be executed again with history referencing.
	System stores a history buffer for executed commands long
	enough (8 chars).  These commands can be referenced in a
	simple manner. You can either search the command with 
	shortest matching beginning of the line or with line number.
	Line numbers can be seen by listing the history buffer with
	'command -hist'. Referencing is done with '%' in the
	beginning of the line. Examples:

	%		-Reference the last stored command.
	%3		-Reference the line 3 in the list.
	%say		-Reference the line where you last
			 said something.

NOTE
	If user wants to avoid alias, command or dq going to the command
	queue, they should not be aliased because aliases will go into
	the queue. (this is why 'dq' is so short).

	You can't make command aliases named as 'command', 'alias' or
	'dq' either.

SEE ALSO
	alias, command, dq.

//Tron


