SYNOPSIS unknown call_direct (object ob, string fun, mixed arg, ...) unknown call_direct (object *ob, string fun, mixed arg, ...) DESCRIPTION Call a member function in another object with an the argument(s) . Result is the value returned from the called function (or 0 for non-existing or void functions). This efun is a twin to call_other(), with the difference being that call_direct() never calls a default method. Optionally the driver can be configured to accept an array of objects as : the function is called with the same arguments in all the given objects. The single results are collected in an array and yield the final result. Array elements can be objects or the names of existing objects; destructed objects and 0s will yield a '0' as result, but don't cause an error. If the array-calling mode is available, the macro __LPC_ARRAY_CALLS__ is defined. The object(s) can be given directly or via a string (i.e. its object_name). If it is given by a string and the object does not exist yet, it will be loaded. ob->fun(args) and "ob_name"->fun(args) is equivalent to call_other(ob, "fun", args). Nowadays the ob_name string can also be a variable. ob->fun(args) and ob->"fun"(args) are equivalent to call_other(ob, "fun", args). ob->(fun)(args) are equivalent to call_other(ob, fun, args) where fun is a runtime expression returning the function name. If ob::fun does not define a publicly accessible function, the call_other() will return 0, which is indistinguishable from a function returning 0. "publicly accessible" means "public" when calling other objects, and "public" or "static" when calling this_object(). "private" and "protected" function can never be called with call_other(). The return type of call_other() is 'any' be default. However, if your LPC code uses #pragma strict_types, the return type is 'unknown', and the result of call_other() must be casted to the appropriate type before you can use it for anything. EXAMPLES // All the following statements call the lfun QueryProp() // in the current player with the argument P_SHORT. string str, fun; str = (string)call_direct(this_player(), "QueryProp", P_SHORT); fun = "QueryProp"; str = (string)call_direct(this_player(), fun, P_SHORT); You have to do explicit type casting because of the unknown return type, if you have set #pragma strict_types. // This statement calls the lfun short() in all interactive users // and stores the collected results in a variable. string * s; s = (string *)call_direct(users(), "short"); HISTORY Introduced in LDMud 3.3.113 with the H_DEFAULT_METHOD hook. LDMud 3.2.10 made the call on arrays of objects configurable. SEE ALSO call_other(E), call_direct_resolved(E), create(A), pragma(LPC), extern_call(E), function_exists(E), functions(LPC)