diff --git a/doc/efun/call_direct b/doc/efun/call_direct
new file mode 100644
index 0000000..94ab028
--- /dev/null
+++ b/doc/efun/call_direct
@@ -0,0 +1,75 @@
+SYNOPSIS
+        unknown call_direct (object ob, string fun, mixed arg, ...)
+        unknown call_direct (object *ob, string fun, mixed arg, ...)
+
+DESCRIPTION
+        Call a member function <fun> in another object <ob> with an
+        the argument(s) <arg...>. 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 <ob>: 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)