Server Built-in Functions
abs() acos() add_property() add_verb()
asin() atan() binary_hash() boot_player()
buffered_output_length() builtin-index call_function() caller_perms()
callers() ceil() children() chparent()
clear_property() connected_players() connected_seconds() connection_name()
connection_option() connection_options() cosh() create()
crypt() ctime() db_disk_size() delete_property()
decode_binary() delete_verb() disassemble() dump_database()
encode_binary() equal() eval() exp()
floatstr() floor() flush_input() force_input()
function_info() idle_seconds() index() is_clear_property()
is_member is_player() kill_task() length()
listappend() listdelete() listen() listeners()
listinsert() listset() log() log10()
match() max() max_object() memory_usage()
min() move() notify() object_bytes()
open_network_connection() output_delimiters() parent() pass()
players() properties() property_info() queue_info
queued_tasks() raise() random() read()
recycle() renumber() reset_max_object() resume()
rindex() rmatch() shutdown() seconds_left()
server_log() server_version() set_player_flag() set_property_info()
set_task_perms() set_verb_args() set_verb_code() set_verb_info()
setadd() setremove() sin() sqrt()
strcmp() string_hash() strsub() substitute()
suspend() task_id() task_stack() ticks_left()
time() tofloat() toint() toliteral()
tonum() toobj() tostr() trunc()
typeof() valid() value_bytes() value_hash()
verb_args() verb_code() verb_info() verbs()

A

=== help abs() =================================== 

Syntax:	abs (num <x>)   => num

Returns the absolute value of <x>. If <x> is negative, then the result is `-<x>'; otherwise, the result is <x>. A NAME="acos">

=== help acos() ================================== 

Syntax: acos (FLOAT <x>)   => FLOAT

Returns the arc-cosine (inverse cosine) of x, in the range [0..pi]. Raises E_INVARG if x is outside the range [-1.0..1.0].

=== help add_property() ============================ 

Syntax: add_property (obj <object>, str <prop-name>, <value>, list <info>)   => none

Defines a new property on the given <object>, inherited by all of its descendants; the property is named <prop-name>, its initial value is <value>, and its owner and initial permission bits are given by <info> in the same format as is returned by `property_info()'.
If <object> is not valid or <object> already has a property named <prop-name> or <info> does not specify a legitimate owner and permission bits, then `E_INVARG' is retuned.
If the programmer does not have write permission on <object> or if the owner specified by <info> is not the programmer and the programmer is not a wizard, then `E_PERM' is returned.

=== help add_verb() =============================== 

Syntax: add_verb (obj <object>, list <info>, list <args>)   => none

Defines a new verb on the given <object>. The new verb's owner, permission bits and name(s) are given by <info> in the same format as is returned by `verb_info()'. The new verb's direct-object, preposition, and indirect-object specifications are given by <args> in the same format as is returned by `verb_args()'. The new verb initially has the empty program associated with it; this program does nothing but return an unspecified value.

If <object> is not valid, or <info> does not specify a legitimate owner and permission bits, or <args> is not a legitimate syntax specification, then `E_INVARG' is retuned.
If the programmer does not have write permission on <object> or if the owner specified by <info> is not the programmer and the programmer is not a wizard, then `E_PERM' is returned.

=== help asin() =================================== 

Syntax: asin (FLOAT <x>)   => FLOAT

Returns the arc-sine (inverse sine) of x, in the range [-pi/2..pi/2]. Raises E_INVARG if x is outside the range [-1.0..1.0].

=== help atan() =================================== 

Syntax: atan (FLOAT <y> [, FLOAT <x>])   => FLOAT

Returns the arc-tangent (inverse tangent) of y in the range [-pi/2..pi/2] if x is not provided, or of y/x in the range [-pi..pi] if x is provided.

B

=== help binary_hash() ============================= 

Syntax: binary_hash (STR bin-string)   => STR
        string_hash (STR text)         => STR

Returns a 32-character hexadecimal string encoding the result of applying the MD5 cryptographically secure hash function to the contents of the string `text' or the binary string `bin-string'. MD5, like other such functions, has the property that, if

string_hash(x) == string_hash(y)

then, almost certainly equal(x, y)

This can be useful, for example, in certain networking applications: after sending a large piece of text across a connection, also send across the result of applying string_hash() to the text; if the destination site also applies string_hash() to the text and gets the same result, you can be quite confident that the large text has arrived unchanged.

=== help boot_player() ============================= 

Syntax: boot_player (obj <player>)   => none

Immediately terminates any currently-active connection to the given <player>.
If the programmer is not either a wizard or the same as <player>, then `E_PERM' is returned.
If there is no currently-active connection to <player>, then this function does nothing.

If there was a currently-active connection, then the following two verb calls are made before the connection is closed: 

    <player>:disfunc()
    <player>.location:disfunc(<player>)
It is not an error if either of these verbs do not exist; the corresponding call is simply skipped.

=== help buffered_output_length() ===================== 

Syntax: buffered_output_length ([OBJ conn])   => INT

Returns the number of bytes currently buffered for output to the connection `conn'.
If conn is not provided, returns the maximum number of bytes that will be buffered up for output on any connection.

=== help builtin-index ==============================

Retorna a lista de comandos do Server Built-in Functions (#1020) - mostrada no início deste documento.

C

=== help call_function() ============================= 

Syntax: call_function (STR func-name, arg, ...)   => value

Calls the built-in function named `func-name', passing the given arguments, and returns whatever that function returns. Raises E_INVARG if func-name is not recognized as the name of a known built-in function. This allows you to compute the name of the function to call and, in particular, allows you to write a call to a built-in function that may or may not exist in the particular version of the server you're using.

=== help caller_perms() ============================ 

Syntax: caller_perms ()   => obj

Returns the permissions in use by the verb that called the currently-executing verb.
If the currently-executing verb was not called by another verb (i.e., it is the first verb called in a command or server task), then `caller_perms()' returns `#-1'.

=== help callers() ================================= 

Syntax: callers ()   => list

Returns information on each of the verbs currently waiting to resume execution in the current task. When one verb calls another verb, execution of the caller is temporarily suspended, pending the called verb returning a value. At any given time, there could be several such pending verbs: the one that called the currently executing verb, the verb that called that one, and so on. The result of `callers()' is a list, each element of which gives information about one pending verb in the following format: 
    {<this>, <verb-name>, <programmer>, <verb-loc>, <player>}
where <this> is the initial value of the variable `this' in that verb, <verb-name> is the name used to invoke that verb, <programmer> is the player with whose permissions that verb is running, <verb-loc> is the object on which that verb is defined, and <player> is the initial value of the variable `player' in that verb.

The first element of the list returned by `callers()' gives information on the verb that called the currently-executing verb, the second element describes the verb that called that one, and so on. The last element of the list describes the first verb called in this task.

=== help ceil() =================================== 

Syntax: ceil (FLOAT <x>)   => FLOAT

Returns the smallest integer not less than x, as a floating-point number.

=== help children() ================================ 

Syntax: parent (obj <object>)   => obj
       	children (obj <object>) => list

These functions return the parent and a list of the children of <object>, respectively.
If <object> is not valid, then `E_INVARG' is returned.

=== help chparent() =============================== 

Syntax: chparent (obj <object>, obj <new-parent>)   => none

Changes the parent of <object> to be <new-parent>.
If the programmer is neither a wizard or the owner of <object>, or if <new-parent> is not fertile (i.e., its `f' bit is not set) and the programmer is neither the owner of <new-parent> nor a wizard, then `E_PERM' is returned.
If <object> is not valid or if <object> or one of its descendants defines a property with the same name as one defined either on <new-parent> or on one of its ancestors, then `E_INVARG' is returned.

Changing an object's parent can have the effect of removing some properties from and adding some other properties to that object and all of its descendants (i.e., its children and its children's children, etc.).
Let <common> be the nearest ancestor that <object> and <new-parent> have in common before the parent of <object> is changed.
Then all properties defined by ancestors of <object> under <common> (that is, those ancestors of <object> that are in turn descendants of <common>) are removed from <object> and all of its descendants.
All properties defined by <new-parent> or its ancestors under <common> are added to <object> and all of its descendants.
As with `create()', the newly-added properties are given the same permission bits as they have on <new-parent>, the owner of each added property is either the owner of the object it's added to (if the `c' permissions bit is set) or the owner of that property on <new-parent>, and the value of each added property is "clear"; see the description of the built-in function `clear_property()' for details. All properties that are not removed or added in the reparenting process are completely unchanged.

=== help clear_property() =========================== 

Syntax: clear_property (obj <object>, str <prop-name>)  	=> none
    	is_clear_property (obj <object>, str <prop-name>)  => boolean

These two functions test for clear and set to clear, respectively, the property named <prop-name> on the given <object>.
If <object> is not valid, then `E_INVARG' is returned. If <object> has no non-built-in property named <prop-name>, then `E_PROPNF' is returned.
If the programmer does not have read (write) permission on the property in question, then `is_clear_property()' (`clear_property()') returns `E_PERM'.

If a property is clear, then when the value of that property is queried the value of the parent's property of the same name is returned.
If the parent's property is clear, then the parent's parent's value is examined, and so on.
If <object> is the definer of the property <prop-name>, as opposed to an inheritor of the property, then `clear_property()' returns `E_INVARG'.

=== help connected_players() ======================== 

Syntax: connected_players ()   => list

Returns a list of the object numbers of those player objects with currently-active connections.

=== help connected_seconds ========================= 

Syntax: connected_seconds (obj <player>)   => num
        idle_seconds (obj <player>)   	   => num

These functions return the number of seconds that the currently-active connection to <player> has existed and been idle, respectively.
If <player> is not the object number of a player object with a currently-active connection, then `E_INVARG' is returned.

=== help connection_name() ========================= 

Syntax: connection_name (obj <player>)   => str

Returns a network-specific string identifying the connection being used by the given player.
If the programmer is not a wizard and not <player>, then `E_PERM' is returned. If <player> is not currently connected, then `E_INVARG' is returned.

For the BSD UNIX network implementation (the only publicly-available one as of this writing), the string has the form 

    "<number> from <host>"
where <number> is a remarkably uninteresting internal server index and <host> is either the name or decimal TCP address of the host from which the player is connected.

=== help connection_option() ======================== 

Syntax: connection_option (OBJ conn, STR name)   => value

Returns the current setting of the option <name> for the connection <conn>.
Raises E_INVARG if <conn> does not specify a current connection and E_PERM if the programmer is neither <conn> nor a wizard.

=== help connection_options() ======================= 

Syntax: connection_options (OBJ conn, STR name)   => LIST

Return a list of (<name>, <value>) pairs describing the current settings of all of the allowed options for the connection <conn>. Raises E_INVARG if <conn> does not specify a current connection and E_PERM if the programmer is neither <conn> nor a wizard. 
Syntax:  cos (FLOAT x)   => FLOAT
         sin (FLOAT x)   => FLOAT
         tan (FLOAT x)   => FLOAT
Returns the cosine, sine, or tangent of <x>, respectively.

=== help cosh() ================================== 

Syntax:  cosh (FLOAT x)   => FLOAT
         sinh (FLOAT x)   => FLOAT
         tanh (FLOAT x)   => FLOAT

Returns the hyperbolic cosine, sine, or tangent of <x>, respectively.

=== help create() ================================= 

Syntax: create (obj <parent> [, obj <owner>])   => obj

Creates and returns a new object whose parent is <parent> and whose owner is as described below. Either the given <parent> object must be fertile (i.e., its `f' bit must be set) or else the programmer must own <parent> or be a wizard; otherwise `E_PERM' is returned. `E_PERM' is also returned if <owner> is provided and not the same as the programmer, unless the programmer is a wizard. After the new object is created, its `initialize' verb, if any, is called with no arguments.

The new object is assigned the least non-negative object number that has not yet been used for a created object. Note that no object number is ever reused, even if the object with that number is recycled.

The owner of the new object is either the programmer (if <owner> is not provided), the new object itself (if <owner> was given as `#-1'), or <owner> (otherwise).

The other built-in properties of the new object are initialized as follows: 

	name         	""
	location     	#-1
	contents     	{}
	programmer   	0
	wizard       	0
	r            		0
	w            	0
	f            		0
In addition, the new object inherits all of the other properties on <parent>. These properties have the same permission bits as on <parent>.
If the `c' permissions bit is set, then the owner of the property on the new object is the same as the owner of the new object itself; otherwise, the owner of the property on the new object is the same as that on <parent>. The initial value of every inherited property is "clear"; see the description of the built-in function `clear_property()' for details.

If the intended owner of the new object has a property named `ownership_quota' and the value of that property is a number, then `create()' treats that value as a "quota".
If the quota is less than or equal to zero, then the quota is considered to be exhausted and `create()' returns `E_QUOTA' instead of creating an object. Otherwise, the quota is decremented and stored back into the `ownership_quota' property as a part of the creation of the new object.

=== help crypt() ================================== 

Syntax:	crypt (str <text> [, str <salt>])   => str

Encrypts the given <text> using the standard UNIX encryption method.
If provided, <salt> should be a two-character string for use as the extra encryption ``salt'' in the algorithm.
If <salt> is not provided, a random pair of characters is used. In any case, the salt used is also returned as the first two characters of the resulting encrypted string.

Aside from the possibly-random selection of the salt, the encryption algorithm is entirely deterministic. In particular, you can test whether or not a given string is the same as the one used to produced a given piece of encrypted text; simply extract the first two characters of the encrypted text and pass the candidate string and those two characters to `crypt()'.
If the result is identical to the given encrypted text, then you've got a match. 

	crypt("foobar")         	=>   "J3fSFQfgkp26w"
	crypt("foobar", "J3")  	 =>   "J3fSFQfgkp26w"
	crypt("mumble", "J3")   	=>   "J3D0.dh.jjmWQ"
	crypt("foobar", "J4")  	 =>   "J4AcPxOJ4ncq2"

=== help ctime() ================================== 

Syntax: ctime ([num <time>])   => str

Interprets <time> as a time, using the same representation as given in the description of `time()', and converts it into a 28-character, human-readable string in the following format: 
    Mon Aug 13 19:13:20 1990 PDT
If the current day of the month is less than 10, then an extra blank appears between the month and the day: 
    Mon Apr  1 14:10:43 1991 PST
If <time> is not provided, then the current time is used.

Note that `ctime()' interprets <time> for the local time zone of the computer on which the MOO server is running.

D

=== help db_disk_size() ============================ 

Syntax: db_disk_size()   => INT

Returns the total size, in bytes, of the most recent full representation of the database as one or more disk files. Raises E_QUOTA if, for some reason, no such on-disk representation is currently available.

=== help decode_binary() =========================== 

Syntax: decode_binary (STR bin-string [, fully])   => LIST

Returns a list of strings and/or integers representing the bytes in the binary string <bin-string> in order. If <fully> is false or omitted, the list contains an integer only for each non-printing, non-space byte; all other characters are grouped into the longest possible contiguous substrings.

If <fully> is proved and true, the list contains only integers, one for each byte represented in lt;bin-string>. Raises E_INVARG if lt;bin-string> is not a properly-formed binary string. (See the LambdaMOO programmer's manual on MOO value types for a full description of binary strings.) 

decode_binary("foo")               =>  {"foo"}
decode_binary("~~foo")             =>  {"~foo"}
decode_binary("foo~0D~0A")         =>  {"foo", 13, 10}
decode_binary("foo~0Abar~0Abaz")   =>  {"foo", 10, "bar", 10, "baz"}
decode_binary("foo~0D~0A", 1)      =>  {102, 111, 111, 13, 10}

=== help delete_property() ========================== 

Syntax: delete_property (obj <object>, str <prop-name>)   => none

Removes the property named <prop-name> from the given <object> and all of its descendants.
If <object> is not valid, then `E_INVARG' is returned.
If the programmer does not have write permission on <object>, then `E_PERM' is returned.
If <object> does not directly define a property named <prop-name> (as opposed to inheriting one from its parent), then `E_PROPNF' is returned.

=== help delete_verb() ============================= 

Syntax: delete_verb (obj <object>, str <verb-name>)   => none

Removes the verb named <verb-name> from the given <object>.
If <object> is not valid, then `E_INVARG' is returned.
If the programmer does not have write permission on <object>, then `E_PERM' is returned. If <object> does not define a verb named <verb-name>, then `E_VERBNF' is returned. 7

=== help disassemble() ============================= 

Syntax: disassemble (OBJ object, STR verb-desc)   => LIST

Returns a (longish) list of strings giving a listing of the server's internal "compiled" form of the verb as specified by <verb-desc> on <object>. This format is not documented and may indeed change from release to release, but some programmers may nonetheless find the output of `disassemble()' interesting to peruse as a way to gain a deeper appreciation of how the server works.

If <object> is not valid, then E_INVARG is raised. If <object> does not define a verb as specified by <verb-desc>, then E_VERBNF is raised. If the programmer does not have read permission on the verb in question, then disassemble() raises E_PERM.

=== help dump_database() ========================== 

Syntax: dump_database ()   => none

Requests that the server checkpoint the database at its next opportunity. It is not normally necessary to call this function; the server automatically checkpoints the database at regular intervals; see the chapter on server assumptions about the database for details.
If the programmer is not a wizard, then `E_PERM' is returned.

E

=== help encode_binary() =========================== 

Syntax: encode_binary(arg, ...)   => STR

Each argument must be an integer between 0 and 255, a string, or a list containing only legal arguments for this function. This function translates each integer and string in turn into its binary string equivalent, returning the concatenation of all these substrings into a single binary string. (See the early sections in the LambdaMOO Programmer's Manual on MOO value types for a full description of binary strings.) 
encode_binary("~foo")                     =>  "~7Efoo"
encode_binary({"foo", 10}, {"bar", 13})   =>  "foo~0Abar~0D"
encode_binary("foo", 10, "bar", 13)       =>  "foo~0Abar~0D"

=== help equal() ================================== 

Syntax: equal(value1, value2)   => INT

Returns true if <value1> is completely indistinguishable from . This is much the same operation as "<value1> == <value2>" except that, unlike ==, the `equal()' function does not treat upper- and lower-case characters in strings as equal.

Raises E_ARGS if none, one, or more than two arguments are given. 

equal(1, 2)                   => 0
equal("ChIcKeN", "chicken")   => 0
equal("ABC123", "ABC123")     => 1

=== help eval() ================================== 

Syntax:	eval (str <string>)   => list

The MOO-code compiler processes <string> as if it were to be the program associated with some verb and, if no errors are found, that fictional verb is invoked.
If the programmer is not, in fact, a programmer, then `E_PERM' is returned. The normal result of calling `eval()' is a two element list. The first element is true if there were no compilation errors and false otherwise. The second element is either the result returned from the fictional verb (if there were no compilation errors) or a list of the compiler's error messages (otherwise).

When the fictional verb is invoked, the various built-in variables have values as shown below: 

	player    	the same as in the calling verb
	this      		#-1
	caller    		the same as the initial value of `this' in the calling verb

	args      		{}
	argstr    		""

	verb      		""
	dobjstr   	""
	dobj      		#-1
	prepstr   	""
	iobjstr   		""
	iobj      		#-1
The fictional verb runs with the permissions of the programmer and as if its `d' permissions bit were on. 
	eval("return 3 + 4;")   =>   {1, 7}

=== help exp() =================================== 

Syntax: exp (FLOAT x)   => FLOAT

Returns `e' raised to the power of <x>.

 F

=== help floatstr() ================================ 

Syntax: floatstr (FLOAT x, INT precision [, scientific])   => STR

Converts <x> into a string with more control than provided by either `tostr()' or `toliteral()'. <Precision> is the number of digits to appear to the right of the decimal point, capped at 4 more than the maximum available precision, a total of 19 on most machines; this makes it possible to avoid rounding errors if the resulting string is subsequently read back as a floating-point value.
If <scientific> is false or not provided, the result is a string in the form "MMMMMMM.DDDDDD", preceded by a minus sign if and only if <x> is negative. If <scientific> is provided and true, the result is a string in the form "M.DDDDDDe+EEE", again preceded by a minus sign if and only if <x> is negative.

=== help floor() ================================== 

Syntax: floor (FLOAT x)   => FLOAT

Returns the largest integer not greater than x, as a floating-point number.

=== help flush_input() ============================= 

Syntax: flush_input (OBJ conn [, show-messages])   => none

Performs the same actions as if the connection <conn>'s definied flush command had been received on that connection, i.e., removes all pending lines of input from <conn>'s queue and, if <show-messages> is provided and true,prints a messages to <conn> listing the flushed lines, if any. See the chapter in the LambdaMOO Programmer's Manual on server assumptions about the database for more information about a connection's defined flush command.

=== help force_input() ============================= 

Syntax: force_input (OBJ conn, STR line [, at-front])   => none

Inserts the string <line> as an input task in the queue for the connection <conn>, just as if it had arrived as input over the network. If <at-front> is provided and true, then the new line of input is put at the front of <conn>'s queue, so that it will be the very next line of input processed even if there is already some other input in that queue. Raises E_INVARG if <conn> does not specify a current connection and E_PERM if the programmer is neither <conn> nor a wizard.

=== help function_info() ============================ 

Syntax: function_info ([STR name])   => LIST

Returns descriptions of the various built-in functions available on the server. If <name> is provided, only the description of the function with that name is returned. If <name> is omitted, a list of descriptions is returned, one for each function available on the server. E_INVARG is raised if <name> is provided but no function with that name is available on the server.

  I

=== help idle_seconds() ============================ 

Syntax:	connected_seconds (obj <player>)   	=> num
   	idle_seconds (obj <player>)   		=> num

These functions return the number of seconds that the currently-active connection to <player> has existed and been idle, respectively.
If <player> is not the object number of a player object with a currently-active connection, then `E_INVARG' is returned.

=== help index() ================================= 

Syntax:	index (str <str1>, str <str2> [, <case-matters>])   	=> nu
       	rindex (str <str1>, str <str2> [, <case-matters>])   	=> num

The function `index()' (`rindex()') returns the index of the first character of the first (last) occurrence of <str2> in <str1>, or zero if <str2> does not occur in <str1> at all. By default the search for an occurrence of <str2> is done while ignoring the upper/lower case distinction. If <case-matters> is provided and true, then case is treated as significant in all comparisons. 
	index("foobar", "o")        	=>   2
	rindex("foobar", "o")      	=>   3
	index("foobar", "x")        	=>   0
	index("foobar", "oba")      	=>   3
	index("Foobar", "foo", 1)   	=>   0

=== help is_clear_property() ======================== 

Syntax: clear_property (obj <object>, str <prop-name>)  	 => none
      	is_clear_property (obj <object>, str <prop-name>)  	 => boolean

These two functions test for clear and set to clear, respectively, the property named <prop-name> on the given <object>.
If <object> is not valid, then `E_INVARG' is returned. If <object> has no non-built-in property named <prop-name>, then `E_PROPNF' is returned.
If the programmer does not have read (write) permission on the property in question, then `is_clear_property()' (`clear_property()') returns `E_PERM'.
If a property is clear, then when the value of that property is queried the value of the parent's property of the same name is returned.
If the parent's property is clear, then the parent's parent's value is examined, and so on. If <object> is the definer of the property <prop-name>, as opposed to an inheritor of the property, then `clear_property()' returns `E_INVARG'.

=== help is_member ============================== 

Syntax: is_member (ANY value, LIST list)   => INT

Returns true if there is an element of <list> that is completely indistinguishable from <value>. This is much the same operation as "<value> in <list>" except that, unlike `in', the `is_member()' function does not treat upper- and lower-case characters in strings as equal.

Raises E_ARGS if two values are given or if more than two values are given. Raises E_TYPE if the second argument is not a list. Otherwise returns the index of <value> in <list>, or 0 if it's not in there. 

  is_member(3, {3, 10, 11})                 => 1
  is_member("a", {"A", "B", "C"})           => 0
  is_member("XyZ", {"XYZ", "xyz", "XyZ"})   => 3
Each function description is a list of the following form: 
  {<name>, <min-args>, <max-args>, <types>}
where <name> is the name of the built-in function, <min-args> is the minimumnumber of arguments that must be to the function, <max-args> is the maximumnumber of arguments that can be provided to the function or -1 if there is nomaximum, and <types> is a list of <max-args> integers (or <min-args> if <max-args> is -1), each of which represents the type of argument required in the corresponding position.
Each type number is as would be returned from the `typeof()' built-in function except that -1 indicates that any type of value is acceptable and -2 indicates that either integers or floating-point numbers may be given. For example, here are several entries from the list: 
  {"listdelete", 2, 2, {4, 0}}
  {"suspend", 0, 1, {0}}
  {"server_log", 1, 2, {2, -1}}
  {"max", 1, -1, {-2}}
  {"tostr", 0, -1, {}}
`Listdelete()' takes exactly 2 arguments, of which the first must be a list (LIST == 4) and the second must be an integer (INT == 0). `Suspend()' has one optional argument that, if provided, must be an integer. `Server_log()' has one required argument that must be a string (STR == 2) and one optional argument that, if provided, may be of any type. `Max()' requires at least one argument but can take any number above that, and the first argument must be either an integer or a floating-point number; the type(s) required for any other arguments can't be determined from this description. Finally, `tostr()' takes any number of arguments at all, but it can't be determined from this description which argument types would be acceptable in which positions.

=== help is_player() ============================== 

Syntax: is_player (obj <object>)   => num

Returns a true value if the given <object> is a player object and a false value otherwise.
If <object> is not valid, `E_INVARG' is returned.